{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cf493ce8",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32ad6394",
   "metadata": {},
   "source": [
    "这里针对简单的环境建立一个ActorCritic网络，并且只针对离散动作空间进行处理，演员和评论家共享参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d9f53cd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "class ActorCritic(nn.Module):\n",
    "    ''' A2C网络模型，包含一个Actor和Critic\n",
    "    '''\n",
    "    def __init__(self, input_dim, output_dim, hidden_dim):\n",
    "        super(ActorCritic, self).__init__()\n",
    "        self.critic = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, 1)\n",
    "        )\n",
    "        \n",
    "        self.actor = nn.Sequential(\n",
    "            nn.Linear(input_dim, hidden_dim),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, output_dim),\n",
    "            nn.Softmax(dim=1), # 离散动作用softmax输出概率，这样就有策略梯度\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        value = self.critic(x)\n",
    "        probs = self.actor(x)\n",
    "        # 返回动作概率分布和价值\n",
    "        return probs, value "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfa1fd6",
   "metadata": {},
   "source": [
    "### 定义智能体-A3C算法的实现"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b20b9d3e",
   "metadata": {},
   "source": [
    "A3C算法实际上是在A2C算法的基础上实现的，算法原理相同。A2C算法的基本原理是在演员-评论家算法的基础上引入优势函数的概念。评论家是一个函数逼近器，输入当前观测到的状态，输出评分值，也就是Q值。而Q值实际上可以分解为两部分，即Q(s,a)=A(s,a)+V(s)。其中A(s,a)即为优势函数，评价的是在给定状态下当前选定动作相较于其他动作的好坏，它可以通过采样数据计算得出。A2C算法的核心就在于让评论家学习A(s,a)而不再是学习Q(s,a)。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9552c32c",
   "metadata": {},
   "source": [
    "损失函数一般分为三项，策略梯度损失，值残差和策略熵正则。其中，策略梯度损失用于不断优化提升reward，值残差用于使critic网络不断逼近真实的reward，策略熵正则能够为了保证action的多样性，增加智能体探索能力。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f0cf5da1",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "from torch.distributions import Categorical\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg):\n",
    "        self.model = ActorCritic(cfg.state_dim, cfg.action_dim, cfg.hidden_dim)\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr)\n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.gamma = cfg.gamma\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        state = torch.tensor(np.array(state), dtype=torch.float, device=self.device) # [batch_size, state_dim]\n",
    "        if len(state.shape) == 1:\n",
    "            state = state.unsqueeze(0)\n",
    "        probs, self.value = self.model(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        self.log_prob = dist.log_prob(action)\n",
    "        return action.cpu().numpy()[0]\n",
    "\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(np.array(state), dtype=torch.float, device=self.device)\n",
    "        if len(state.shape) == 1:\n",
    "            state = state.unsqueeze(0)\n",
    "        probs, value = self.model(state)\n",
    "        return probs.argmax(dim=1).cpu().numpy()[0]\n",
    "    \n",
    "    def get_policy_transition(self):\n",
    "        policy_transition = {'log_prob':self.log_prob.detach().cpu().numpy().item(), 'value': self.value.detach().cpu().numpy().item()}\n",
    "        return policy_transition\n",
    "        \n",
    "    def learn(self, **kwargs):\n",
    "        states, actions, returns= kwargs['states'], kwargs['actions'], kwargs['returns']\n",
    "        values = kwargs['values']\n",
    "        probs, values = self.model(states)\n",
    "        dist = Categorical(probs)\n",
    "        entropy = dist.entropy().mean()\n",
    "        log_probs = dist.log_prob(actions).unsqueeze(1)\n",
    "        advantages = returns - values\n",
    "        actor_loss = - (log_probs * advantages.detach()).mean() \n",
    "        critic_loss = advantages.pow(2).mean()\n",
    "        loss = actor_loss + 0.5* critic_loss - 0.001 * entropy\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        return actor_loss.item(), critic_loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51a9e338",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31255500",
   "metadata": {},
   "source": [
    "在A3C的训练过程中，通过n_envs定义多个环境，构建多个工作进程，所有的工作进程都会在每个相同的时间步上进行环境交互，经过n_steps步的交互之后，将经验收集后一起计算梯度进行模型更新。需要注意的是，这里在多进程的构建上采用的是同步更新的方法，即在每个时间步上使用的是相同的模型和策略进行交互。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "780ae20c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import gymnasium as gym\n",
    "import ray\n",
    "\n",
    "class Exp:\n",
    "    ''' 经验类\n",
    "    '''\n",
    "    def __init__(self, **kwargs) -> None:\n",
    "        for k,v in kwargs.items():\n",
    "            setattr(self,k,v)\n",
    "\n",
    "def compute_returns_for_exps(exps, gamma=0.95, gae_lambda=0.95):\n",
    "    ''' 计算return，包括MC, TD, GAE\n",
    "    '''\n",
    "    def _get_exp_len(exps, max_step: int = 1):\n",
    "        ''' get exp len\n",
    "        '''\n",
    "        exp_len = len(exps)\n",
    "        if exp_len <= max_step or exps[-1].done:\n",
    "            exp_len = max(exp_len, 0)\n",
    "        else:\n",
    "            exp_len = exp_len - max_step\n",
    "        return exp_len\n",
    "    exp_len = _get_exp_len(exps)\n",
    "    next_value = exps[-1].value\n",
    "    return_mc = 0\n",
    "    return_td = next_value   \n",
    "    adv_gae = 0\n",
    "    returns_mc = []\n",
    "    returns_td = []\n",
    "    returns_gae = []\n",
    "    for t in reversed(range(exp_len)):\n",
    "        delta = exps[t].reward + gamma * next_value * (1 - exps[t].done) - exps[t].value\n",
    "        adv_gae = delta + gamma * gae_lambda * (1 - exps[t].done) * adv_gae\n",
    "        return_mc = exps[t].reward + gamma * return_mc * (1 - exps[t].done)\n",
    "        return_td = exps[t].reward + gamma * return_td * (1 - exps[t].done)\n",
    "        returns_mc.insert(0, return_mc)\n",
    "        returns_td.insert(0, return_td)\n",
    "        returns_gae.insert(0, adv_gae + exps[t].value)\n",
    "        exps[t].return_mc = return_mc\n",
    "        exps[t].return_td = return_td\n",
    "        exps[t].adv_gae = adv_gae\n",
    "        exps[t].return_gae = adv_gae + exps[t].value\n",
    "        next_value = exps[t].value\n",
    "    return_mc_normed = (returns_mc - np.mean(returns_mc)) / (np.std(returns_mc) + 1e-8)\n",
    "    return_td_normed = (returns_td - np.mean(returns_td)) / (np.std(returns_td) + 1e-8)\n",
    "    return_gae_normed = (returns_gae - np.mean(returns_gae)) / (np.std(returns_gae) + 1e-8)\n",
    "    for t in range(exp_len):\n",
    "        exps[t].return_mc_normed = return_mc_normed[t]\n",
    "        exps[t].return_td_normed = return_td_normed[t]\n",
    "        exps[t].return_gae_normed = return_gae_normed[t]\n",
    "    exps = exps[:exp_len]\n",
    "    return exps\n",
    "\n",
    "@ray.remote\n",
    "class EnvWorker:\n",
    "    ''' 多进程worker\n",
    "    '''\n",
    "    def __init__(self, cfg, env, idx, **kwargs):\n",
    "        if not ray.is_initialized():\n",
    "            ray.init(ignore_reinit_error=True)\n",
    "        self.cfg = cfg\n",
    "        self.idx = idx\n",
    "        self.env = env\n",
    "        self.seed = cfg.seed + idx\n",
    "        self.state, _  = self.env.reset(seed=self.seed)\n",
    "\n",
    "    def run(self, policy):\n",
    "        exps = []\n",
    "        for _ in range(self.cfg.n_steps):\n",
    "            action = policy.sample_action(self.state)\n",
    "            next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "            policy_transition = policy.get_policy_transition()\n",
    "            interact_transition = {'state':self.state, 'action':action, 'reward':reward, 'next_state':next_state, 'done':terminated or truncated}\n",
    "            exps.append(Exp(**interact_transition, **policy_transition))\n",
    "            self.state = next_state\n",
    "            if truncated or terminated:\n",
    "                self.state, _ = self.env.reset(seed=self.seed)\n",
    "        return exps\n",
    "    \n",
    "def evaluate_policy(env, policy, vis=False, n_episodes=10):\n",
    "    state,_ = env.reset()\n",
    "    if vis: env.render()\n",
    "    terminated = False\n",
    "    rewards = []\n",
    "    for _ in range(n_episodes):\n",
    "        ep_reward = 0\n",
    "        ep_step = 0\n",
    "        while True:\n",
    "            action = policy.predict_action(np.array(state).reshape(1, -1))\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)\n",
    "            state = next_state\n",
    "            # if vis: env.render()\n",
    "            ep_reward += reward\n",
    "            ep_step += 1\n",
    "            if truncated or terminated or ep_step >=200:\n",
    "                state,_ = env.reset()\n",
    "                rewards.append(ep_reward)\n",
    "                break\n",
    "    return np.round(np.mean(rewards),3)\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    ray.shutdown()\n",
    "    ray.init()\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    env_workers = [EnvWorker.remote(cfg, copy.deepcopy(env), idx) for idx in range(cfg.n_envs)]\n",
    "    policy = Policy(cfg)\n",
    "    frames, test_rewards = [], []\n",
    "    threshold_reward_cnt = 0\n",
    "    for i in range(cfg.max_frame):\n",
    "        exps = ray.get([worker.run.remote(policy) for worker in env_workers])\n",
    "        exps = [compute_returns_for_exps(exp, gamma = cfg.gamma, gae_lambda = cfg.gae_lambda) for exp in exps]\n",
    "        exps = [exp for sublist in exps for exp in sublist]\n",
    "        states = torch.tensor(np.array([exp.state for exp in exps]), dtype=torch.float, device=policy.device)\n",
    "        actions = torch.tensor(np.array([exp.action for exp in exps]), dtype=torch.long, device=policy.device)\n",
    "        log_probs = torch.tensor(np.array([exp.log_prob for exp in exps]), dtype=torch.float, device=policy.device)\n",
    "        rewards = torch.tensor(np.array([exp.reward for exp in exps]), dtype=torch.float, device=policy.device)\n",
    "        values = torch.tensor(np.array([exp.value for exp in exps]), dtype=torch.float, device=policy.device)\n",
    "        returns = torch.tensor(np.array([exp.return_td_normed for exp in exps]), dtype=torch.float, device=policy.device).unsqueeze(1)\n",
    "        actor_loss, critic_loss = policy.learn(states=states, actions=actions, log_probs=log_probs, values=values, returns=returns)\n",
    "        if i % 20 == 0:\n",
    "            frames.append(i)\n",
    "            test_reward = evaluate_policy(env, policy)\n",
    "            test_rewards.append(test_reward)\n",
    "            print(f\"Frame: {i}, Reward: {test_reward}\")\n",
    "            if test_reward >= cfg.threshold_reward:\n",
    "                threshold_reward_cnt += 1\n",
    "        if threshold_reward_cnt >= cfg.threshold_reward_cnt:\n",
    "            print(f\"Threshold reward reached over {cfg.threshold_reward_cnt} times, stop training!\")\n",
    "            break\n",
    "    ray.shutdown()\n",
    "    return {'frames':frames, 'rewards':test_rewards}\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d7d42a4",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "806c6dd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = \"A3C\"\n",
    "        self.env_id = \"CartPole-v1\"\n",
    "        self.mode = \"train\"\n",
    "        self.n_envs = 10\n",
    "        self.device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        self.max_frame = 1000000\n",
    "        self.max_step = 200\n",
    "        self.seed = 1\n",
    "        self.hidden_dim = 256\n",
    "        self.lr = 3e-4\n",
    "        self.n_steps = 20\n",
    "        self.n_epochs = 4\n",
    "        self.threshold_reward = 200 # 目标reward\n",
    "        self.threshold_reward_cnt = 10 # 如果连续N次达到目标reward则停止训练\n",
    "        self.gamma = 0.95\n",
    "        self.gae_lambda = 0.95"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3013fd0a",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d3f81190",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-07-09 14:20:49,397\tINFO worker.py:1612 -- Started a local Ray instance. View the dashboard at \u001b[1m\u001b[32m127.0.0.1:8265 \u001b[39m\u001b[22m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frame: 0, Reward: 23.8\n",
      "Frame: 20, Reward: 8.9\n",
      "Frame: 40, Reward: 13.6\n",
      "Frame: 60, Reward: 15.5\n",
      "Frame: 80, Reward: 138.0\n",
      "Frame: 100, Reward: 131.4\n",
      "Frame: 120, Reward: 124.1\n",
      "Frame: 140, Reward: 131.4\n",
      "Frame: 160, Reward: 138.0\n",
      "Frame: 180, Reward: 138.2\n",
      "Frame: 200, Reward: 180.9\n",
      "Frame: 220, Reward: 157.8\n",
      "Frame: 240, Reward: 197.3\n",
      "Frame: 260, Reward: 160.2\n",
      "Frame: 280, Reward: 130.1\n",
      "Frame: 300, Reward: 195.7\n",
      "Frame: 320, Reward: 172.1\n",
      "Frame: 340, Reward: 165.4\n",
      "Frame: 360, Reward: 186.3\n",
      "Frame: 380, Reward: 106.9\n",
      "Frame: 400, Reward: 138.5\n",
      "Frame: 420, Reward: 200.0\n",
      "Frame: 440, Reward: 200.0\n",
      "Frame: 460, Reward: 196.6\n",
      "Frame: 480, Reward: 182.7\n",
      "Frame: 500, Reward: 196.3\n",
      "Frame: 520, Reward: 200.0\n",
      "Frame: 540, Reward: 197.5\n",
      "Frame: 560, Reward: 182.4\n",
      "Frame: 580, Reward: 200.0\n",
      "Frame: 600, Reward: 164.6\n",
      "Frame: 620, Reward: 176.2\n",
      "Frame: 640, Reward: 200.0\n",
      "Frame: 660, Reward: 193.1\n",
      "Frame: 680, Reward: 200.0\n",
      "Frame: 700, Reward: 200.0\n",
      "Frame: 720, Reward: 200.0\n",
      "Frame: 740, Reward: 200.0\n",
      "Frame: 760, Reward: 200.0\n",
      "Threshold reward reached over 10 times, stop training!\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHJCAYAAACrCBICAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACv5UlEQVR4nOzddXhc1dbA4d8ZzUQbT71N6pK6C6XUcFrgouUCxe3D/cKFi9OLFPdC8QtFCxS3urt70ySN6/ic74/JTJrGk5lMZrLe5+nTduTM3mNnzd5rr62oqqoihBBCCNEKaQLdACGEEEKI2kigIoQQQohWSwIVIYQQQrRaEqgIIYQQotWSQEUIIYQQrZYEKkIIIYRotSRQEUIIIUSrJYGKEEIIIVotCVREnaQeoBCiLvIdIfxNAhVRq19++YW77rrLJ8dauHAhvXv35vDhw369j2hb5s+fz7hx40hPT+fll1+u87bnn38+vXv3ZvHixTVe73K5eOutt5g2bRrp6emcccYZfP311zXedt++ffz73/9mypQppKenM2nSJG699Va2b99eb5uXL1/O9OnTGTBgAFdccUX9nWyiZcuWccMNNzBhwgQGDRrE9OnTefLJJ8nLy/PZY7z88su89dZb3v97PrPH/unbty8jRozg8ssvZ82aNY06/ooVK+jduzcrVqzwWZsb6oknnmD27Nkt/riiOl2gGyBar/nz5/vsWJMmTeKTTz4hKSnJr/cRbUdpaSlPPvkkkyZN4vLLL6dTp0613nbv3r2sW7eOXr168fHHHzN9+vRqt3n++ed56623uOmmmxg4cCB//PEHd9xxBxqNhtNOO817ux9//JE777yTnj17cu2119KpUyeysrJ49913+cc//sErr7zCuHHjam3LU089hcvl4vXXXyc+Pr55T0It5s6dy5tvvsmMGTO47777aNeuHTt27OCNN97gxx9/5P3336d9+/bNfpznn3+eG264odrlL774IomJiYA7AMzNzeWll17in//8J5999hl9+vRp9mP709tvv80777zDyJEjA90UgQQqooXExcURFxfn9/uItqOoqAiXy8WUKVMYMWJEnbdduHAhHTt25Oqrr+b222/nwIEDdO3a1Xu92WzmvffeY/bs2Vx11VUAjBkzhi1btrBgwQJvoHLw4EHuuusuJkyYwHPPPYdWq/UeY9q0aVxwwQXcdddd/PrrrxgMhhrbUlhYyIgRIxg7dmxzn4IaLVq0iDfeeIN77rmHSy+91Hv56NGjOeGEE5g5cyaPPvooL774ol8eH6Bv377VAsd+/foxdepUPvzwQx5++GG/PXZzHDp0iCeffJJff/2VqKioQDdHVJCpH1Gj2bNns3LlSlauXOkdevUMw3788ceceOKJDB06lCVLlgDwv//9j1mzZjF48GDS09M588wz+f77773HO34a5+677+bSSy/l888/9w6Dn3nmmfz555/Nug/AunXruOiiixg8eDCTJk3i3Xff5dJLL+Xuu++us8/r16/n8ssvZ+jQoYwePZpbb72V7OzsGtviMXny5CrH7d27Ny+++CKzZs0iPT2dF198kb59+/L+++9XuV9+fj79+/f3jlp5fmFPnTqVAQMGMH36dBYsWFDv61RSUsLjjz/OlClTGDhwIKeddhqfffZZtTbOmzePJ598krFjx5Kens6cOXPYv39/nce22Ww899xznHTSSaSnp3PaaafxxRdfeK+fPXs2d999N6+++ipjx45l2LBhXHfddWRkZHhvc/fddzN58uQqxz18+DC9e/dm4cKFdT7+kiVLuPDCCxk2bBijRo3itttuIzMzE3C/Hp7j3nvvvfTu3bvW4zidTr788ktOPPFEpkyZQnh4OJ988kmV2xgMBj766CMuv/zyKpfr9XqsVqv3/wsWLMBms3H//fdXCVIATCYTd911F2effTZFRUXV2uHpd0ZGBl9++WWVKY1NmzYxZ84cRo0axdChQ7nmmmvYtWuX9751ffaO9/rrr9OjRw/++c9/VruuW7du3HHHHQwZMsSbW5Kfn89DDz3EiSeeyIABAxg5ciTXX399lff67Nmzuf3227npppsYPHgwl112mfc5f/HFF+t8/j06depEbGwsR44c8V62f/9+brrpJsaNG8fgwYOZPXt2vdNDO3fu5Oqrr2bo0KEMHTqU66+/nkOHDtV5n1dffZUBAwZUe13mz59P//79vdNhjz/+OAcOHODdd9+lb9++9fZJtAwJVESNHnzwQfr160e/fv345JNP6N+/v/e6F198kbvuuosHHniAIUOG8MEHH/DAAw8wZcoUXnvtNebOnYvBYOD2228nKyur1sfYvHmzd6j9pZdeQqvVcuONN9b4Jd/Q++zZs8f7K/KZZ57hxhtv5PXXX6/3y2/r1q1cfPHFWK1WnnrqKR566CE2b97MnDlzcDgcjXjm3F+Kp59+OvPmzWP69OmMHDmSRYsWVbnNDz/8gKqqnHrqqQD8+9//Zt68eZxxxhm8+uqrzJgxg8cee4yXXnqp1sexWCxceOGFfPPNN1xxxRW8/PLLDBs2jPvuu49XX321ym3fe+899u7dy+OPP84jjzzC5s2b680/uv3223nnnXc499xzee211xg/fjx333033377rfc2v/zyCwsXLuT+++/noYceYtu2bcyePRuz2dyo5+x4X375JZdffjnt27fnmWee4Z577mHdunWcd9555OXlMWnSJO+IwLXXXlst8DjWn3/+SU5ODmeddRZhYWGcfPLJfPHFF9hsNu9ttFotffr0ITExEVVVyc3N5fXXX2fp0qVceOGF3tv99ddf9OvXj+Tk5Bofa8yYMdxyyy3eaY9jJSUl8cknn5CYmMgJJ5zg/VwtX76cCy64AIDHHnuMRx55hMzMTM4//3z27NlT5RjHf/aOl5OTw/bt25k0aRKKotTYxgsvvJA5c+agKAqqqnL11VezZMkSbr/9dt566y1uuOEGli1bxoMPPljlft9//z0RERG88sorXHHFFd7n/Jxzzqnz+fcoKCigoKCALl26ALB7925mzZrF4cOHuf/++5k7dy6KovDPf/6TlStX1niMffv2cf7555OXl8eTTz7Jo48+yqFDh7jgggvqzL05/fTTcTgc/Pjjj1UuX7RoEePHj/dOwd188818/fXX9Y7QiZYlUz+iRj169CAyMhKAwYMHV7nuwgsvZMaMGd7/Hzp0iDlz5nDdddd5L+vYsSOzZs1izZo13pPx8UpKSli4cKH3iys8PJyLL77Ym2zYlPu89tprREVF8eabb2IymQBITU3l/PPPr7O/r776Ku3atePtt9/GaDQC7hPLbbfdVuWXbUMMHz6cyy67zPv/M888k3vvvZcjR47QoUMHwP0FOXbsWBITE9m3bx+ffvopt956q3faYfz48SiKwmuvvcaFF15IbGxstcdZuHAhO3fu5OOPP/aetCZMmIDD4eDll1/m/PPPp127dgBER0fz8ssve0cBDh48yAsvvEBBQUGNx965cyeLFy/m3nvv9f4yHzNmDBkZGaxYscI7FWI2m1m4cCGdO3cG3M/1zJkz+fLLL70n38ZyuVzMnTuX8ePH89///td7+dChQznllFN46623uPPOO72/eLt06VLtPXr889SrVy8GDhwIwKxZs/jss89YvHgxp59+erXbL1q0iNtuuw1w50mdccYZ3uuysrKa/EvbYDAwePBgDAYDcXFx3jb/97//pWvXrrz++uve12f8+PFMnTqVefPm8fzzz3uPcfxn73ieEae68nWOdfToUe9I0PDhwwEYNWoUBw8erBZ86PV6HnrooWpTWikpKdWef5fL5Q3wrVYr+/fvZ+7cuWg0Gs477zzAHXQZDAbee+8973fNpEmTOO2003jqqaeqjQx67mMymZg/f773PmPGjGHKlCm8+eabtQbfHTt2ZMSIEXz77bece+65gPszsHHjRp599lnv7Xr16tWg5020LBlREY12/Bf13Xffze23305xcTHr16/nq6++4oMPPgCo8qv1eHFxcd6AA9xfeECdv8bru8/y5cuZOHGiN0gBGDJkCB07dqyzT2vWrGHixIneIMVzv19//bXRJ6bjbz9t2jSMRiPfffcd4D6ZrFmzhjPPPNPbZlVVmTx5Mg6Hw/tn8uTJWK3WWkeDVq5cSceOHav9sj7jjDOwWq1s2LDBe9nAgQOrTFXU91x7HnPatGlVLn/hhRf4z3/+4/3/0KFDvUEKuPMQOnfuzKpVq2o8bkPs27ePnJycKgms4A5IhgwZUuuv7Zrk5+fz22+/MX36dIqLiykuLqZnz5507Nix1lGA9PR03n//ff71r3+xdu1arrjiCu80iVarxel0NrlvxysvL2fTpk2cfPLJVV6f6OhoTjzxxGp9re+9qNO5f3u6XK4GPX5ycjLvvfcew4YN4/DhwyxZsoQFCxawdu3aap/d1NTUWvNujjd16lT69+9P//79GTp0KLNmzeLAgQM8/fTT3mmilStXcuKJJ3oDDk/7Tz31VDZv3kxZWVm14y5fvpyRI0cSFhbm/ZxERkYyfPhwli5dCrin+o79HHmeizPOOINVq1aRk5MDuAPSyMjIalOTovWRERXRaOHh4VX+f/DgQR544AGWLVuGXq8nNTXVm9VfV42FY4MJwDtUXdeXbH33yc/Pr3ElRUJCQq3HBHeCo69WYBz//ERGRjJlyhQWLVrEFVdcwXfffYfJZGLKlCnexwZqHXny5Mkcr6ioqMYpBk9fi4uLvZcd/7xpNO7fKLU915421fec1DQFEh8fX+f0XX08j13Ta5aQkMDWrVsbfKyvv/4au93OCy+8wAsvvFDluoyMDPbs2UNaWlqVy7t06UKXLl0YMWIEkZGR3HXXXaxevZoRI0bQoUOHKjkWx7Pb7RQVFdX7fvMoKSlBVdVa+1pSUlLlsuPfW8dr3749iqJUyRM6XlFRETqdjoiICMD9HD3zzDNkZmbSrl07+vbtS1hYWLX7eW7fEK+88or3vanX64mNja32XqnteUpISEBVVUpLS6tdV1hYyHfffecN+o/lSbyfOnVqlf7PnDmTJ554ghkzZvCf//yH77//nksuuYRFixYxffr0GvsqWhcJVESzuFwurrrqKvR6PZ999hl9+/ZFp9Oxe/duvvrqqxZvT0pKCrm5udUuz8vLIzU1tdb7RUVFkZ+fX+3yP/74g759+9YaRNX0q68mZ5xxBldddRUHDhzwfkF6gofo6GgA3n333RpPBp7pouPFxMRw4MCBapd7fjHWNKXTUJ425efne0dfwJ0DVFhYyLBhwwB33sHxcnNzvaNeiqJUG4EoLy+v87E901U1vY45OTmN6tfnn3/OkCFDuOWWW6q14brrruOjjz7i/vvvJz8/nz///JMJEyZUCc769esHuKdIwD0l8+6775KTk1NjkPjHH39w/fXX8+KLLzJ16tR62xcVFYWiKLX21fNcNFRsbCz9+/fnr7/+4o477qgxT+XFF1/k448/5rfffmP//v3cddddzJ49mzlz5niDiaeeeqrRNU+O1atXr3qnn2JiYmrtt6cvxyd8R0VFMXbs2CpTqx6e0aRXXnmlymiQ5/0SFRXF5MmT+f777xk9ejS7du3iX//6V6P6JQJDpn5ErTy/uutSUFDAvn37OOeccxg4cKD3y8KzEqehQ9C+MmLECP76668qKzW2bt1ab9G44cOHs2TJkipfcFu3buWqq65iy5Yt3uHpY5ODPSfthhg/fjwJCQm89957bNmyxTvt43lscD+XAwcO9P7Jz8/n+eefr/UxRowYQUZGBuvWraty+ddff41eryc9Pb1BbauJJxD59ddfq1w+d+5cHn30Ue//16xZUyVY2bx5M4cPH2bMmDGA+1d4QUFBldejvhNg9+7dSUxMrJK0C+5cqPXr1zN06NAG9WHTpk3s3LmTWbNmMWrUqCp/TjzxREaPHs1XX32FxWLBYrFw1113VcuL8Kys8UxXXHTRRej1eh599NEaA7B58+YRGxvLxIkTG9TG8PBwBgwYwPfff1/leCUlJfz+++/e16Ex5syZw86dO6utNAN3Auvnn3/O2LFjSUhIYN26dbhcLm688UZvkOJ0Or3TKPV9fhvyHVGbESNG8Ntvv1UZOXE6nSxatIiBAwfWOM00cuRIdu/eTd++fb2fkwEDBjB//nx++uknwP1aHfs5OjZgOvPMM1m/fj0fffQRHTp0kDopQUJGVEStoqOjWbduHcuWLfP+sjxefHw8HTt25IMPPiAlJYXo6Gj++usv3nvvPaDufBN/uOaaa/juu++44ooruPzyyykuLub5559Ho9HUugoC4LrrruO8887j6quv5pJLLsFisfDcc8+Rnp7OuHHjsFgshIWF8cQTT/B///d/lJWVMW/evAb/4tVqtZx66qm8//77JCcnM2rUKO91vXv35owzzuBf//oXGRkZDBgwgH379vHss8/SqVMnunXrVuMxZ82axYcffsj111/PTTfdRKdOnfj111/5/PPPueGGG7yjIk3Rp08fZsyYwdNPP43FYqFv3778+eef/Pbbb1Xqb5jNZq644gquvfZaysrKePbZZ+nVq5c3v+TEE09kwYIF3HfffZxzzjns3LmTd955p9rS3mNpNBpuvfVW7rnnHm677TbOOOMMCgoKePHFF4mJianx13RNPv/8c/R6fbU8G48zzzyTpUuX8t133zFr1izOPvtsXnrpJXQ6Hf369WP16tW8/vrrnHPOOfTo0QNwJ6n++9//5r777uOiiy7i/PPPp3379hw8eJB33nmHQ4cO8dZbb1XJdarPbbfdxpw5c7jqqqu48MILsdvtvP7669hsNq6//voGH8fjlFNOYenSpTzyyCNs2LCBGTNmEB4ezsaNG3nnnXeIjY3lkUceAfAGsw8//LB3WfUHH3zgrbBbXl5eJYfkeNHR0axdu5ZVq1Z5A+6GuuGGG/jzzz+55JJLvKOy77//PocOHeLNN9+s8T7XXXcd559/PldffTUXXHABRqORTz75hJ9//pl58+bV+5gTJkygXbt2fPLJJ1xxxRV1fieI1kNGVEStPL8er7zyymq1So718ssvk5yczN13383NN9/Mhg0beOWVV0hNTWX16tUt2GLo2rUrb731FlarlZtuuolnn32WK6+8ksTExDrn2Pv168eCBQtwOBzcfPPNPPLIIwwbNozXXnsNg8FAdHQ0L7zwAk6nk+uvv57nn3+e66+/ngEDBjS4bWeeeSZOp5PTTjut2i/Rxx9/nMsuu4yPP/6YK664gldffZVTTjmFt99+u9aTuslkYsGCBZx44ok8//zzXHvttaxZs4ZHH32UG2+8scHtqs3TTz/N7Nmzeffdd7n66qtZvnw58+bN8+bWgHs06MQTT+S+++7jscceY8yYMbz33nveX8Pjxo3jrrvuYs2aNVx55ZV89913vPjii3UGKuAOwubNm8e+ffu4/vrreeKJJxgyZAifffZZjVMux7NarSxatIhx48bVGkxOmzaN8PBwPv74Y8C9RPzaa6/l008/5corr+Trr7/mpptuqpI8DO6cB0/A+dxzz3HFFVfwyiuv0K9fP7788stG/0ofM2YM77zzDhaLhVtvvZV//etfJCcn8+mnnzZ5FcojjzzC3Llzyc7O5oEHHuDaa6/lq6++4txzz63yHI4aNYoHHniAdevWceWVV/LEE0/QoUMHbzBa3+jXNddcw+bNm7nyyiu9K44aqmfPnnz44YfEx8dzzz33cMcdd6CqKu+9916txfD69OnDBx98gKIo3Hnnndx0003k5OTw0ksv1RqQHsuTrOt0Oqus5hKtm6LKjlIihHgSeo/9dVdcXMzYsWO58847ueSSSwLYutDi2QelIYXphBCiqWTqR4SULVu2MG/ePG699Vb69+9PYWEh77zzDlFRUdWWuwohhGj9JFARIeXyyy/HZrPx0UcfkZmZSXh4OCNHjuTxxx+XfYOEECIIydSPEEIIIVotSaYVQgghRKslgYoQQgghWi0JVIQQQgjRakmgIoQQQohWKyRW/aiqisvl+5xgjUbxy3Fbq7bUX+lr6GpL/ZW+hq620F+NRmlQdeCQCFRcLpX8/IZtDtdQOp2G2NgIiovLcThadr+aQGhL/ZW+hq621F/pa+hqK/2Ni4tAq60/UJGpHyGEEEK0WhKoCCGEEKLVkkBFCCGEEK2WBCpCCCGEaLUkUBFCCCFEqyWBihBCCCFaLQlUhBBCCNFqSaAihBBCiFZLAhUhhBBCtFoSqAghhBCi1Wp0oFJYWMgDDzzAxIkTGTp0KBdccAGrV6/2Xr9s2TJmzZrFoEGDmDFjBosWLapyf6vVykMPPcSYMWMYMmQIt912G/n5+c3viRBCCCFCTqMDlVtvvZV169bxzDPP8Pnnn9O3b1/mzJnD3r172bNnD1dffTUTJkxg4cKFnHvuudx5550sW7bMe/9///vf/P3337zwwgu8++677N27l5tuusmnnRJCCCFEaGjUpoQHDhxgyZIlfPjhhwwbNgyAf/3rX/z1119888035OXl0bt3b2655RYA0tLS2Lp1K2+++SZjxowhOzubL7/8kldffZXhw4cD8MwzzzBjxgzWrVvHkCFDfNw9IYQQQgSzRgUqsbGxvP766wwcONB7maK4t2kuLi5m9erVTJkypcp9Ro8ezaOPPoqqqqxZs8Z7mUf37t1JTk5m1apVzQpUdDrfpttotZoqf4e6ttRf6Wvoakx/i8tsfL/8AGaro8HHN+i1jE9vT5fkqCa30Vca09cyi52/NhxBq9Ewql8y0REGfzevTsVlNn5dc5iThnciKrz+tvj7fbx2Zw75xRYmD+uERql/N9/GcDhd/LjyEEcLyht8H0VRMBh02GwOVFX1aXuaIjbKyKlju6EL0PdIowKV6OhoTjjhhCqXLV68mAMHDnDvvffyxRdfkJKSUuX6pKQkzGYzBQUFZGdnExsbi9ForHabrKysJnYBNBqF2NiIJt+/LtHRJr8ct7VqS/2VvoauhvT3xzWHWbTsQKOP/cOKg4xNb88F0/rQrX10U5rnU3X11e5w8f3SfXz8005Kym0AfPjTTob1SWbyiM6M7JeMXqdtqaZ6vfHtNv5an4Gi1XDpaf0bfD9/vI/LLXZeWrgJu8NFbrGVa2alo/goWHE4XTy1YDXLNmX65HiBNHZwJ3p1iQ3IYzcqUDne2rVrueeee5g2bRqTJk3CYrFgMFSNjj3/t9lsmM3matcDGI1GrFZrk9vhcqkUFzc8Wm0IrVZDdLSJ4mIzTqfLp8dujdpSf6Wvoasx/T14pBiAAd3j6NW5XYOOfzinlFXbjrJ0YyZLN2Yysm8SZ01MpVNiZHOb3mh19VVVVVZszeaz3/ZwtNAMQIeECIx6Lfsyi1m5NYuVW7OIMOkZ3S+Z8entSe0Q7bMTdF1KzXaWbToCwNa9eRQUlNV7H3++j9fsOIrd4T7md0v343A4uWhqr2Y/F06Xi1e+2MzKbUfRazVMH9UFQwNH/hWNgtGox2q1o7pax4hKfIS+Qa9VY0RHmxo0StbkQOXnn3/m9ttvZ+jQocydOxdwBxw2m63K7Tz/N5lMhIWFVbse3CuBTKbmRcoOh3++hJ1Ol9+O3Rq1pf5KX0NXQ/qbV2wBYFS/ZMYNbN/gY582tpSvl+xn9fajrNx2lFXbjjKibxKnj+tOxwT/jOzW5fi+7jhYwKe/7WZfZgkAMREGzprQnfHp7dFqNGTklrF0cybLNmdRWGrjlzWH+WXNYdrHhzN2QApj+qcQFx3mt/Yu2ZiJw+k++R7IKsFudzY4KPDH+3jD7jwAOiZEkJFbxo8rD6FB4dwT05ocrLhcKm9+u5WV246i1ShcP2sA6WkJDb6/TqchNjaCgoKyVvO5dblUXAEKmpoUqLz//vs8+uijzJgxgyeffNI7StK+fXuOHj1a5bZHjx4lPDycqKgoUlJSKCwsxGazVRlZOXr0KMnJyc3ohhBCNE5BiXsUNzbKWM8tq+qUGMl1Zw3g8NFSvlqyjzU7crwBy8h+yZwxrhvt41s+YDmSW8Znv+9h/e5cAIx6LSeP6sL0kV0wGiqndzomRHDupB6cPTGNrQfyWbopi7U7c8jMK+fzP/ay8I+99O0Wy9gBKYzok4zex/l/f2044v13udVBXrGFhJjATE2qqsqmPe5A5exJaRSWWHlv8Q5+WHkQrVZh1sTURgcrLlXlne+2sXxrNlqNwnUzGxekiOoaHah8+OGH/Oc//2H27Nncd999VV7E4cOHs3Llyiq3X758OUOHDkWj0TBs2DBcLhdr1qxhzJgxAOzbt4/s7GxGjBjRzK4IEXgWm4M3v93G0F4JjB3Q8F/pouXlV4yoNDZQ8eiUFMn1MwdyMLuEr5fsZ+3OHFZszWbltmxG9UvmjHHdSYkL92WTa1RYYuXzP/bw54YjqCpoFIUTBnfgjPHdiakjaVajURjQPZ4B3eMxWx2s3n6UJZuz2HmokK37C9i6v4C1O3O5YdbAWo/RWAeySjh4tBSdVqFdpJHcIgsHs0sDFqhk5ZeTV2xBp1Xo2yUWo0GLw+niw593sWjZAXRaDWeO797g47lUlfd+2M6SzVloFIWrz+jPkJ6JfuxB29CoQGXfvn089thjTJ06lauvvprc3FzvdWFhYcyePZuZM2cyd+5cZs6cyR9//MEPP/zAm2++CUBycjKnnnoq999/P4899hgmk4kHH3yQkSNHMnjwYJ92TIhAWL8rl7U7cziYXSKBSitmtjqw2JxA0wMVjy7JUdwwayAHskr4esk+1u3KZfmWbFZszWbcgPbMnt7LLwmrFpuDDxdvZ+Fvu7Ha3X0Z0jOBcyalNXpEx2TUMWFQByYM6sDRQjPLNmfxTUXwdTC7xGernP7e6E4qHdorEb1WQ25RFgezSxjaKzAnc89oSu/O7byjTlOGd8bpUvnk19189fc+tBqF08Z2q/dYqqrywY87+XNDJooCV53Rj+F9kvzZ/DajUYHK4sWLsdvt/PTTT/z0009Vrps5cyZPPPEEL7/8Mk8//TTvvvsunTp14umnn/aOngD85z//4bHHHuOGG24AYOLEidx///0+6IoQgZeR6042yy2yUG5xEB7WrHx14Sf5FdM+4UYdYQbfvEZdU6K48ex0DmSV8NXf+1i/O5e/N2WSHGfi1DHdfPIYHnaHk4fmr+ZIxfstrUM0557Yo8FJwXVJamfizPHdycwrY+W2o/y06hBzTuvX7OPaHU6Wb3Wv7hyf3p7M3HKWbM7iYHZps4/dVJv2ugOVAanxVS6fPrILTpfKZ7/vYeGfe9FpNcwY1aXW46iqykc/7+K3dRkowBWn9mNkX0ln8JVGfUKvueYarrnmmjpvM3HiRCZOnFjr9eHh4TzyyCM88sgjjXloIYJCRk5lVvzhnFKfnDia45c1h/n6733cdv5gOgQgb6K1KiipmPaJbt5oSk26pkRx0znp/LnhCPO/387ilYeYMqxzlTyR5vpzQyZHcsuIiTQwe3pvhvRI8PmKnWkjurBy21GWb81m1glpzR55WrcrlzKLg7hoI/26xqGvWO1xILvEF81tNKvNyY5DhQAMPC5QAThldFccThdf/rWPT3/bjVajMHVE52q3U1WVT3/bzc9rDgNw6Sl9GDMgpdrtRNO1jSpQQrSQwzmlNf47UFZuzaagxMrv6zIC3ZRWpaC4aYm0jTFuYApJ7UyUmu38vt53z7/d4eK75e76LxdM68PIvsl+WVac2iGanp1icLpUfl17uNnH8yTRjhvQHo1G8U4nFZRYvTVeWtL2gwU4nCrx0Ubax9ecS3TGuO6cXjHt89Evu6o9D6qqsvDPvSxeeQiAS2b0ZkJ6B7+2uy2SQEUIH7HanOQWWbz/P3Q08IGKZ2XLxt15raLCZWvheV7i/BioaDUaThnTFXAXibM7nD457l8bj1BQYiU2ysi0OqYjfGHaCPfxf1+XgdXW9PbnFpnZur8AcE/7gDsvJqmdO4n2YAA+K5v3ujfDHZgaX2egd9aE7pw82v08vP/jTv44Juj86u993qKBF03txaTBHf3Y4rZLAhUhfORIXtViSIdbQaBSWOo+IR8tNJNdYA5wa1qPfO/SZP/VCwEYOyCF+GgjRWU2/trY/OqkdofLe2I8bWw3v1eVHdIzgaR2JsosDpZsbnr7l27KQgX6do0lsV3lCp8uye5CeQcDMP1TW37K8RRF4ZwT0phWMe3z3g87+HtjJt8s3c/XS/YDcP5JPTlpWCe/trctk0BFCB/xTPV4phMO55ThCuAoxrErW6ByhYNomREVAJ1Ww8mj3aMq3y0/gKOZVVX/3pRJQYmVdpEGThji/ykGzTF5GT+uOtSkgl8uVeXvihLyntEUj84V0z8tnVCbXVDO0UIzWo1C3671l4VXFIXzJvfgpGGdUIF3vtvGF3/uBeDcEyuDGOEfEqgI4SOeRNohPRPQ6zRY7U5yAjiK4RlN8di4VwIVD38m0x5vQnp7YiIM5BdbWbq56XuaOZwuvlu2H4CTR3fF0EJ79Iwf2J6IMB1HC8xs2J1b/x2Os+NAAblFFkxGHcOOW4bcNUAjKp6gvWenGEzGhq0pURSFC6f0ZNKQjnjCtVkTUzl5VFc/tVJ4SKAihI94lop2Tor0llIPZJ5KYcWogcnoPqHtOFjorbfR1hW00NQPgF6n9S5t/W7ZAZyupo2q/L0pk7xiKzGRBk4Y1HIJm0aDlhMqci8WrzrU6Pv/VTGaMqpfMgZ91eDKk1CblVferByYxtp0TH5KYyiKwsXTenHhlJ5ceVq/BtVXEc0ngYoQPuKpodIxMZJOSe5figENVErdKyl6do4lISYMh9PF9gMFAWtPa2G1OSmzOAD/T/14TBrckUiTnqOFZlZuPVr/HY7jcLpYtNSdm3LKqK7VTvj+dtKwTmg1CjsPFbIvs7jB9yu32FmzIwdwjywdr12kkegIAyott0rOZney46D7c9DYQAXclX+nDO8sS5BbkAQqQvhAmcXu/ZXeMSGCzhWBSiCXKBdUTP3Ex4SRnub+Qt4k0z/kV0z7hBm0DR72by6jQcv0ke48hm+X7W907tLSzVnkFVuIiTBwwuCWX/4aG2X0FjD7sRGjKiu2ZmN3uOiYGEG3lJqr27Z0Qu3OQ4XYHC5io4x0TJTaQsFAAhUhfMCTnxIXbcRk1NE5sRWMqJR4AhUTg3q4N0XbuEeWKTd1M8Lmmjy0E+FGHZl55aytGGVoCIfTxbdL9wNw8qguLT6a4uEJtFZtO0reMcvw6+JZ6TQhvUOtS4C7Vkz/HGihhFrPtM+A7nF+qT8jfE8CFSF8wJOf0jHBHaB4pn48pfQDwTOiEhcdRr9ucei0CrlFFrLyywPSntaipVb8HM9k1DFluHsJ6zdL9zc4YFy2OYvcIgvREQZOGBK4Oh1dkqPo2zUWl6ryy5r6C8AdOlrK/qwStBqF0f1rLyfvGX1sqREVz6hiU6Z9RGBIoCKED3hGVDxDyZEm/THLlAMzquJZ9RMXE4bRoPWW8/f8omyrWqqGSk2mDHeX0j90tJQNu+ufhnM4XXxbsdJnxsguGAM0muLhWYb7x4YMzNa6A3DPBoSDeyYQHV77Ls6eEZXDOWVNTjRuqJxCM1n55WgUhX7d6l+WLFoHCVSE8IGMXHcw4lntA5W/FAM1/VNY4k6mjY9xn5A9vyDbep5KoKZ+wB3ATh7qHhVpyKjK8i3Z5BRaiArXc2IAR1M8BqbF0z4+HLPVWWcBO7vDxbIt7qXYNSXRHisx1kSYQYvD6SIzz7+jfZsr3vs9OkYTHqb362MJ35FARQgfOHzciAoQ0IRal6pWjqhEVw1UdhwsbNGloK1NQXHL1VCpyfQRXTDoNOzLLGbL/tpHt5yuytyUGaO6+HRTw6bSKJUF4H5efajWEZANu3MpNdtpF2mgf/e4eo/ZUtM/3vwUmfYJKhKoCNFMxWU2Ss12FKB9fOsYUSk123FWVBH1THG0jw8nPtq9THnbwba7TDlQOSoe0REGb12SbytKsNdk+ZZsjhaa3aMwQ1pPefax/VOINOnJLbKwdmfNBeA8oy3jBrZHq6n/NNOlBSrU2h0uth1o+rJkETgSqAjRTBkVIyaJsaYqOQTHjqi0dCl9z4qf6AgDep37Y64oiixTpjJHJS4AOSoeM0Z1QadV2Hm4yFvT41itcTTFw6DXeqevflx5sNr1+cUWNu9zv7+OL5lfmy4tMKKy67C74GFMhMG7JFoEBwlUhGimw94VP1VrMiTFmtDrNNjsrhYvpe+Z9mkXWTWJ0ZunEqBlylv257P7cFGLP66H3eGk1GwHAjf1A+78mPHp7noo31QEJMdaufUo2QXmKjktrcmJQzuh02rYc6S42uu5dHMWqgq9OrcjOTa8Qcc7dkTFX+/LzbIsOWhJoCJEMx2/4sdDq9EErJS+pyrt8QmjfbvGBmyZ8tFCM898sp5n/7ehSZvb+YJn2seg1xDeQsXeanPKqC5oNQpb9xewJ6PyZO9yqd7gZfrIzoQZAtvOmsREGBhTseR48arKURWXqnpX+9SXRHusjokRaDUK5VZHg2u0NJZ3WXKaTPs0hqqqqH5ejVUfCVSEaKbja6gcK1Cl9AtrWYIbyGXKa3YcRVXduzqXWewt+tgex+7xE+hf1QntTIzp7y7D/u0xoyort2WTlV9ORJiOyUNbT27K8TxLldfuzOFooXvEcNehQo4WmjEatAzvndTgY+m0lUG9Pwq/5RdbyMgtQ1GgX7e6k3vbOtXlxHl0L7aNP2D+cR5l791I6bvX4Spu/NYPviKBihDNoKpq5dLkGspxByqhtqCWqR84dvqn8TvhNsex1ViLywMTqOQXBzaR9ninjOmKosCGPXkcyCqpMpoybWSXFivx3xQdEyMZkBqHqsLPFWX1PUm0o/omNTqvpnL6x/d5Kp7RlNQO0USaZFnysVSHFceRbVjXfEX5oqcpnX8d5V8+jHX5xzj2r0W1lqLojKAJXJ5U6/0UCBEECkqsmK1OtBqFlLjq8/GeUvotvUS5sI5aIelp8Xzy6252HHIvU26JRM38Ygt7jlRuZldSZoOElt9nxbPPTyBqqNQkJS6ckX2TWbE1m2+X7Wd47yQy89yjKVOGtd7RFI/pI7qweW8+f23MZPrILqze7v7V7cm/aYwuyZGwyV+BSsVuyd1l2ke1lePM3IkzayeOrJ24cvaB67hyBcYItMk90bXvhTalF5qEbijawIULEqgI0QyeHZOT48LRaasPUHZOrlpKPzysZT5ylTkq1Ve2pMSFkxATRm6RhW0HCxhcsQ+QP63dWXVvm+Jym98fsyaBLPZWm1PHdGXF1mzW7Mjx7kw8dUTnVj2a4tGvWyydEiM4nFPGvM83YnO4aB8fTlqH6EYfyzui4uPRR4fTxdaKejVtMT9FdTpwHt2DM2MLjoytuI7uBbVqzokSEYs2xR2UaNv3QhPbEUVpPRMurf+TIEQr5k2krWV0ICJMT1y0kfxiK4dzSr35If7mnfqJqj71oygKA1Pj+W1dBpv25rVooKIAKlASoKmfQNdQqUmnxEiG9Upkzc4c8outhBt1TBnWOdDNahBFUZg2ogtvf7fNO71Z1waEdfFMkxaUWCkptxFVR9n9xtiTUYTF5iTSpKdrLTs4hxJVdeHKP+wNTJyZO8BR9YeBEp2Mrn1vtO17oU3pjRKVEPCcrbpIoCJEM3hqqNS1XXynxEjyi60cOtoygYrD6XJPrQCxkTWfkL2BSsUyZX9+SRWX29hxqBCA/qlxbN6bT0mARlQCuc9PXU4b2401FcHc1BGdW2zkzRdG9Uvm8z/2UFRmQ6MojBmQ0qTjmIw6kmJNHC0wczC7tN6Ktg1VWY02Dk0rPhk3h6skF0fGFpwZW3FmbEW1VJ0+U0zRaDv2Q9ehH9qO/dBE+f/HiS8Fz6dBiFaothoqx+qcFMnGPXktlqdSXGZDBbQahaiImn+VHr9M+diKur62bmcOqurefC61fTSb9+YHLJm2NU79AHRNiWL6yM4czC5l6vDgGE3x0Os0TBneic//2MuQngnE1PKea4guyVEVgUqJDwOV0NstWXU5cWbvxnFgPc5DG3AVHKl6A50Rbfve6Dr2R9upH5rYTq16xKQ+EqgI0UQuVSXTE6gk1l7psqVX/nimfWIiDbX+gvQsU966v4BNe/L8Gqh4RgqG9U705l14RnxaksPpotgz0hTAYm+1OW9yz0A3oclOHtWVpNhw+nZt3o7EXZMjWb39KAd8lFBbUOIeyVTAZ4FPoKiWUhyHNuI4uAHHoU1gO6YOkqJBk5TqDkw69kOblBbQ5FdfC52eCNEAqqry7Cfrcapw87npzTpWbqEZm8OFTqshqZ2p1ttVKaXvUtFo/PvLxrNrcrtapn080lPj3YHK3jymjezil7aUW+xs2+8uET+sd6J388ZAJNN6VkLptBqiZImqT2k0CiP6NLxuSm06J7lzSHwV1HtK+XdrH0W0j3JeWoqqqjjzDmHduw7nwQ04j+6GY6v2GiPQdU5H12UQus4DUYwtv4qupUigItqUwlIb63a564fsPlxEj44xTT6WJ5G2Q0J4ncFHlVL6hWaSa1jG7Eue8vm15ad4DEyL52M/L1NevzsXp0ulQ0IE7eMjvCMagUimzT8mkTaYh8FDWdeKVXJZeeU+eU96lyUHybSP6nLizNyB7cAaSg5uwFFctdaRJq6zOzDpMghNUhpKAzZ8DAUSqIg25UhemfffG3bnNitQaUh+ClSW0t+fVcKho6UtFqjUN6JSZZnygQIG9/R9gt2aiiJvw3olAnhXcgQimba15qeISjGRRmIiDBSV2TiUU9qsz6fT5WLrPk8ibesNVFSXA2fGNhz7VuHY5y6w5qXVu5NgPcFJZOvthz9JoCLalKy8ynnd9btzOfuEtCYf60gD8lM8OidFegOV4T4YIq+LZ4qjpqXJx6q2TNnHgYrF5mBzxYliWG9PoOKecimzOHA4XTXWnvEXb6DSCvNTRKUuyVFs2pvHweySZgUqe48UU251EBGmI7V94+u6+JPqtOM8vAX7vlU4DqwHa+UPKCUsCn33ocQNHIclpjtORaYpJVARbcqxIyoZOWXkFplJiKk9v6Qu3qXJDaiw2pJ7/jR0RAWoEqj4epnypr352B0uEtuFefN0Ikx6FMU91V5Sbm/R0Y384tZVlVbUrEtypDdQaQ7PtE//7nF+zwtrCNVhw3F4E469q93Bib1yR3XFFI2u+3B03Yejbd8bvUFPeGwE1oIycAR2Q8DWQAIV0aZ4RlQ8J8uNe/KatPGbw+kis+JYddVQ8eiS1HKl9AsqqtK2a8AJ2Z/LlNfscJdTH9Y7yRsAaRSFqHADxWU2SsptLRo0VBZ7a101VERVXb17/jTvs9IaliWrLgfOQ5ux717mDk4cVu91SkRsZXCS3LPN5Js0hQQqok3JrBhRGT2gPcs2ZTY5UMkuMON0qRgNWuKj6z/xeUZUWqKUvnfqpwEjKkaDlt6d27HFx8uU7Q4nG/a4TxSe/BSP6HB9RaDSsgm1+ZKjEhQ8204czilr8vRgUZmNA1nuEZkBLbwsWVVVXLn7se9aimP38irF15TIeHTdh6NPHYEmKbVVlalvzZr1bfnaa6/x999/s2DBAgBmz57NypUra7ztk08+yVlnnYXT6WTIkCFYrdYq199www3ceOONzWmOEHUqtzi8e+CcdUIayzZlsu1AATa7E4O+casLjhyTSNuQ6ZKWKqVvtTsptzqA+lf9eAxMjWfL/gI2+nCZ8pZ9BVhtTmKjjHQ/bt8Xd0JtWYsvUS5oZRsSipoltjMRZtBisTnJyiv3BvmNsaViWXKX5EhiGvg5aC5XaZ47ONm1FFdhpvdyxRSNLm00+h6j0SR2lxVnTdDkQOWDDz7gueeeY/jw4d7LXnjhBez2yl9Jqqpyyy23UFRUxNSpUwHYv38/VquVr776ivj4yiG58HD/roQQIivfPVXTLtJA325x3sBh+8EC0tMal0jamPwUj5Yope/JTzHoNZiMDQu+PMuUdx4qxGJzEGZo/mjPmp3uaZ+hvRKrFZ3zJNS2ZNE3h9NFUUWQ2pr2+RHVaRSFLkmR7DxcxIHskiYFKi21LFm1mXHsXYV911Kcmdsrr9Dq0XUbir7nOLSd+qNo/L9DeShr9DdSdnY2Dz74ICtWrKBbt25VrmvXrl2V/7///vts3LiRr776iogI9xf6jh07iIyMpE+fPk1utBBN4Zn26VAxCjK4RwK/rs1gw568JgQqDV/x4+Eppe/PhNpjp30a+svt2GXK2w8UNnv1j8PpYn1FrZrjp30Ab+GtEnPLTf00ZFsB0Xp0SY5i5+EiDmaXMm5g4+6bXVDuzY8a1MjPdUOodivOjK0VeSfrwFn5PtZ26Iu+51h03YejGJqWpC+qa3SgsmXLFvR6PV9//TUvvfQSGRkZNd4uPz+f5557jmuvvZbU1FTv5Tt27CAtrelLQmuj0/l2rk9bMS+qbcHlk4HUFvqbXeDOsu+Q4A4uhvRO4te17o35tFqlUUOyGRVTP12SIxv83utWsUQyI7fU5+9XD8/JPy7KiE6nafDrOqhHAr+sOczm/fkM79u85dPbDxZQZnEQFa6nXw0rLjxJvqVme4t9bosqpplio4yNnuZrrUL5M9u9QzSscSefN+Z9DPDpr7txOFUGpsbTu2s7n0y1OIuysR/YgP3ABhxHtlcJTjSxHTD0Goex1xifbfYXyq9tUzQ6UJk8eTKTJ0+u93ZvvPEGYWFhzJkzp8rlO3fuxOFwMGfOHLZv305ycjL//Oc/OfPMMxvbFC+NRiE21j/lg6Oj21ZUHMr9zSly5yikdmoHwOj0Duj/t4HcIgslNhddUxpWa8Fmd3K0wD2N1L9nErENSKYF6N/DPbpwOKeM6JhwtH5YMmlxuEtsJ8VHVPlM1Pe6jh3c0R2o7M2jXbvwZn25b9q3233M9A7Ex1cfcUqpGIUy21wt9rm1HSwEIDE23G+PGSih+Jkd0DMJ2MrBo6VV3o/19XXt9qOs25WLVqNw7TmDiItr/LQRuOucWA5uo3z3Gsr3rMWeV3XTP11MIuG9RhI18AQMKal+yzsJxde2Kfyy9KC0tJRPP/2UG264AaOx6nzwrl27cLlc3HTTTaSkpPDHH39wzz33YLfbOeecc5r0eC6XSnFxef03bAStVkN0tIniYjNOZ+ivY28L/T2YVQxAfEUhNJvFTt+usWzck8dfaw8RPaZbg45zIKsEl+quCYLDQUFBWf13AsJ1CnqdBqvNyc59uaT4oULtkaPuFQYRRi0FBWUNfl27xIej0yocLTCzZXdOo3JvjuVyqSzd6P5SH9g9rsbnRos7mMorKm/wc9dQtfX3UGYR4F5x5OvHDJRQ/sxGGTVoNQplZju79uWRkhBRb18dThevLtwAwJQRnYk0aBr1WrvKCryjJvbDW8BuqbxSo0WX0gt910Houw5CE9sBRVEoB8oLfXvugdB+bY8VHW1q0KiRXwKVn3/+GZvNxtlnn13tum+//Ran0+nNWenTpw9HjhzhrbfeanKgAuDwU1Ecp9Plt2O3RqHaX4fTRXa+e+onOdb9K8XpdDEwNZ6Ne/JYvzOX6SMatuLlYMWyx44JETidKqDWfYdjeErp7z9STEIDR2Iaw1PULCbcUOV1rO911WoU7zLl9TtzSK5jk8W67DxUSFGZDZNRR69OMTU+ZoTRnUxbXGZrsc9tbmHFip9IY8i9v0P1M9sxMYKD2aXsPVJE4jGf2dr6+uPKg2TmlRMVruf0MV0b9JyoLieOfWuwbf4RV/buKtcppmi0nQeh65KOrlN/FIP7h4UKjf7cN1WovraN5bdA5YQTTiA6uvpQelhY9S/nXr168fXXX/ujKUIAcLTAjEt11z05dnlqelo8H/wEuw4XUW6xEx5Wf7nqjAbu8VMTTyn9g34qpV9ZPr/xK1s8y5Q37c1jehOXKXv29hncI6HW+hdRERWBSgvWUZF9foJPl+QoDmaXciC7lFH9675tcZmNr5bsA+DsE9Lq/RyrllJs2//EvuVn1LL8iksVNEnd0XWu2FcnoYvUOWkl/PIqrF69mjFjxlS7vLi4mJEjR7Jw4cIql2/atImePXv6oylCAJUrftrHVc2/SGxnon18OC5V9e5LUx/v0uQGVKQ9nmep5WE/rfzx1IlpSLG34w1Mcy/l9CxTbixVVVlbsSx5eO/qq308PKt+rDYnVruz0Y/TFPlSQyXoeCrUHmpAKf2Ff+7BbHXSNTmK8QPb13o7Z+ERLH+/R+mHt2Jb+SlqWT6KKRrD0DOJuPhZIs56AOOwM9EmdpMgpRXx+YhKZmYmBQUFNS4/jo6OZvTo0Tz77LPEx8fTtWtXfvzxR77++mtee+01XzdFCC9PufuaKq+mp8WTmVfOxj15jOybXO+xmjOi0sWPe/6oqlq5z08TTsgpceEktgsjp9DCW99u4+oz+zeqKuj+rBLyiq0Y9Vr611ENNMygRadVcDhVSsptGJu411JjyIaEwadLRYXag/V8VvZnFfPXBneBtQun9qy2ykxVVZyHN2Pb/CPOQ5u8l2viO2MYMA1d2igUnSxZb818Hqjk5LiHfo+vqeLx2GOP8cILL/Dggw+Sl5dHWloa8+bNY8KECb5uihBe3hGV+OoJrOlpCSxeeYhNe/NwqWq1AmXHstgc5FasHmpMDRUPz4hKXrHvS+mXWx3YKuaz2zWhVoiiKMye1pt5n29kzc4cXv1qC9c0IljxTPsMTIuvcwmwUrHfT0GJlZJye5M3hWwol0ulsMRT7E32+QkWnRIjUXAHmcVlthpXa6mqyoc/70IFRvdLpmfFij4A1WHFvnMp9s0/4Sr0rNpR0HUbgn7ANLTte0uV2CDRrG/JJ554otpl6enp7Nixo9b7REZGcs8993DPPfc056GFaJS6RlR6dorBZNRSUm5nf2YJqR1qX6Z8JNd9nJgIA5Gmxm+/7s9S+p78lIgwXZNrhQxIjefGs9N54fNNrN2ZwytfbubaswbUG6yoquotslXXtI9HtDdQ8X912qIymzcAjZFibwGnqi4cB9bj2L8GRWdEMUVX+aMJi0YJjybMYCIp1kR2gZkDWSV07RRb9TgOG2s37MGeuZshJiv/6OTAumYXankRqrkIR+YOsFas+tGHoe89EcOAKWiifZ8bJvxLNiUUIU9VVTLzPYFK9REVnVZD/25xrN6Rw8Y9uXUGKs3JT/Ho7KdS+gXNmPY51sDUeG46eyDzPt/Eul25vPyFO1jR11GcLSO3jOwCMzqtpkFly70JtWX+T6j1TPvERBqqTQuIlqO6XDj2rca27htc+Yfqv4NGx/9pTeRH6wlfuozsgwlYiwpxlRfiKi8CWzm9gFtjKm6/Go4Pe5WoRAwDpqLvPUEqxQYxCVREyCsosWK1OdFqFJJia/6ySk9LYPWOHDbsyeOsCak13gaOzU9pWiEpcE//bPBDKX3P9EZTEmmPNyA1npvOGcgLn29i/e5cXv5iE9fNHFhrsOKZ9hnQPQ6Tsf6vlShTRRn9FhhR8WxGKHv8BIbqcuLYvRzb+m8rN+urGOFQ9EZUcwmqpRiXuRi14g92C7gcRFBChA4oyads265qx3aoGkoJJzYxEW1EOxRTDEq4+48mOglth34oGkmKDXYSqIiQ5xlNSWxnqnUKY2CqO/nzQFYJhaXWWk/2PhlR8VNCrTeRNtI30xsDusdz0znpzPtsIxv25PHSF5u4fuYA9Lrq00qeaZ9hDZj2AYj2LlH2f6CSL0uTA0J1OrDvWoJt3beoJe5AFkM4hoHTMPSfghJWe7CvOmyolhJ27z7E179spFOUi0umpWJRw3AZoyhwhPGfT3ZS6tRx/cx0OjfwfSeCk4SaIuRl5taeSOsRE2mkW4p7OeSmvXm13q45K348PIFKRm4pLpfvikZ5pn58eULu3y2O/zsnHYNOw8Y9eby4cDN2R9Ulxdn55RzOKUOrURjUo2F7nXg3JmyBWiqVNVQkkbYlqA4bti0/U/bxnVj/fAe1JAclLArDyHOIvPC/GIedVWeQAqDoDGgi40nu2Y+t9k78lN8FQ/p0DD1Ho+vQl09Wl1Lq1NO3axxDe/l+40HRukigIkJeZX5K3cFFekUdkY17ag5USs12b52SDs0IVJJjw9HrNNjsLo4Wmpt8nOMdu3OyL/U7JljZtDePFxZuqhKsrNnp/rXcp0u7BicYR1UEKi0xoiLF3lqGardi2/gDZR/dgXXJ++4aJeHtMI6+gIgL5mIcfFqj80RiIgzERBpQgf1H3FtgbN2fz9qdOWgUhQun9JSVO22ABCoi5DVkRAXwjgZs2ZePo4b9NY5UHCc+OqxBeRi10WgU74iMLwu/NafYW336dovj5nMHYdBr2Lw3n3mfb8JWUaytctqn4asposLdAU1JSyTTVmwrECc1VHxKVVVchVnYtv2O+ZdXKf3wVqzLP0Y1F6FExGEcN5uI85/CkD4dRd/0595T+G1vRiFOl4uPfnbnqpw4tGOTSgSI4CM5KiLkNXREpWtKFNHheorL7ew6VEjfblWLlvkiP8XDH6X0C/0w9XOsPl1jueXcQTz7vw1s2ZfPC59v5KJpvdmXWYICDOnZ8CH46IiWG1Hx5KhIDZXmUVUVtSgbR+Z2nEe248zcjlpeWOU2SlQihiGnoe85DkXrm9NLl+RINu7JY09GEaXlVjJyy4g06TlrQnefHF+0fhKoiJBWbnFQVDHSUN9uxRpFYWBqPEs2Z7FhT171QMUH+SkenX1cSt/lUr399MeIikfvLu5g5bn/bWTL/gIeW7AGcNeiiWnE43pHVMrtqKrqt+F7l6rK1E8TqaqKWpyNoyIocR6pHpig1aFN6oG2Qx+07XujTemFomlaDZ/adElyj6hs2ZvHkopgfObEVCIasC+XCA0SqIiQlpnvDi7aRRoaVAU2vUcCSzZnsXFPHuefVHX/qYycikDFRyMq4LuVPyXl7qJmilK5osZfeneJ5ZZ/uEdWSs3uqZvGTPtAZY6Kw+nCYnM2ayqtLiXldpwuFQV3HRVRP9XlwL79L2wbFqGW5Fa9UqNDm5yGtn0fd3CSlOb38vNdKpLcPVOvnZMiOWFQB78+pmhdJFARIS0zt2HTPh79u8Wh1Shk5ZdztKCcpNiKrd1V1Sc1VDyqltJv2K7NdfGs+ImOMKBtgboRvTq349Z/DOKZTzfgdKoNXpbsYdRrMeq1WO1OisttfgtUPDVUoiMNjdq3qC1SVReOPSuwrv4CtdiddxSIwOR4CTFhmIxazFZ3TtSFU6rv5yNCmwQqIqR5RlTqS6T1CA/T0bNTDNsPFrJxTx5ThrvvV1xmo9RsR1Eafqy6VC2lX9bsCrW+LPbWUD07teOROaOw2J3ERTc+/yMqXI+1yElJmZ3k2Ppv3xQFxZ78FJn2qY2qqjgPbsC66nNvxVjFFI1hyOno+0xE0QX2udMoCl2To9h+sJCR/ZLp3cVPbxbRakmgIkJaVh17/NRmYFr8MYFKZ6AyPyWpnanJ++gcz5el9L2JtC0YqADExzQ9QTU6wkBukcWv1WnzpYZKnRyZO7Ct/AxndkXVV70Jw6CTMQychqJvPc/Z2ZPSWLk9hzPGdg10U0QASKAiQtqRvNr3+KlNeloC//ttD9sPFmK1OTEatMfkp/huOaQvS+l7Ekabu89PS4pugVoqkkhbM2fuAayrPsN5aJP7Aq0ew4CpGAadUm8xtkDo3SWW0YM6UVBQhsNRvXSACG0SqIiQ5XC6yClwF1RrzIhKh/hwEmLCyC2ysPVAPkN6JpKRW7E02Qcrfjx8mVDr6/L5LSEy3FNG33+1VGSfn6pchZlYV3+BY+9K9wWKFn2fiRiGnoEmQqZUROskgYoIWdkFZlyqSphB26gTuKIopKfF8+vaDDbtyXMHKj5c8eNxfCn95iQI+rPYm794y+iXyYiKv7ksJdhWfoZ9x1+gugAFXY9RGIfNRBOTHOjmCVEnCVREyMrKq0ykbWydjvS0BH5dm8GGPXm4qqz48V2gkhwbjuGYUvr11XmpSzCekKM9tVTM/htRaesbEqqqimPXUqzLPkK1ukfutF0GYxxxNtr4zgFunRANI4GKCFlHmpBI69GnSzsMOg0FJVY27snDYnOi1SgkNyOYOJ5Go9AxMYJ9mSUcOlrarEClcuoneE7IUZ7qtH4aUVGPLfbWhFVJwc5VmIXl73dxHtkGgCa2E8bxs9G17x3glgnROBKoiJB17IhKYxn0Wvp0jWXjnjx+WH4AcFe29XUtjk6Jkd5AZUQTS+nbHS5v4bVgylGprE7rn0ClzOLAXpF42dKroQJJddqxbfgO27pvwOkArQHDsDPde+5o5CtfBB9514qQ5RlRSYlr2nTNoLR4Nu7JY+fhIsC3+SkeXZKjgEwOZpc0+RhFFaMpOq3S4N2LW4PKVT/+mfrJr9iMMDpcj17XNoq9OTJ3YP3rXVyFRwDQdhpA2PhL0ET7Zj8pIQJBAhURklRV9dZQ6ZDQtCmV9LQEYKf3/77MT/FI7RANwJ6MoibveXNsIm0wbXnvKaNfWm7HpapofNz2tlRDRbWUYl3xKfYdfwLugm3GMReiSxsVVO8JIWoigYoISQUlVqx2d15JYjtTk44RHxNGx8QIv9RQ8eicFIlep6HM4iArv7xJ+TTBmJ8ClVM/LlWl3OLw+WhQMCYYN5aqqlh3LsX89weoFveonL7PJIyjzkUx+j6wFiIQJFARISmzYjQlKdbUrLyS9NT4ykDFDyMqOq2G7ilR7DxcxO6MoiYFKsFY7A3cfQ836ii3Oigus/khUHFP/cRGB9fz0lDOomyyvn8f874NAGhiO2CccBm6lJ713FOI4NI2Jm5Fm3OkIpG2OStpANLT4gEw6DVNHpmpT1rHGAD2ZBQ36f7BWOzNw7Pyxx8JtaG6z4/qcmBd/y3FH9/rDlK0egwjziZ81sMSpIiQJCMqIiRV5qc0bxSkV+d2nH1CKontTH7bsbUyUClq0v0Dtc+PL0SH68nO909CbSjWUHEe3Yvlz3e8mweaug1EP+4S1IjG7V4tRDCRQEWEpEwfjagoisKpY7r5oEW18wQqR3LLKLc4CA9r3McyWKd+4JjqtP4YUQmhZFrVZsa6eiH2zT8DKooxEtO4C0kePY3CwnLZ/0aENAlUREjK9NGISkuIiTCQ2C6MnEILezOLGNA9vlH3D8by+R6ehFpfF307tthbsE/9OA6ux/LXe6hl+QDoeozBOOYCDFHtZEWPaBMkUBEhp9xip6jixNfcEZWW0qNjDDmFFnYfbkqgEsQ5Kt4RFd9O/ZRbHVjtTiA4R5oAXOWFWJd+6N1AUIlKIGz8P9F1HhjglgnRsiRQESHHM5oSG2XEZAyOt3haxxiWbclmz5HGJdSarQ4stooTchCOqER7yuj7eOrHk0gbEabDqNf69Nj+pqoq9h1/Yl3+CdjKQVHQD5yOcdhMFH3wvcZCNFdwfIsL0QiZ3oq0wTGaApDWwZ2nsvdIUaOKn3lGU8IM2qAJyo5VWUbftyMq+RVLk+OCbI8fV2EWlr/ewZm5AwBNQlfCJl6GNqFbYBsmRAAF3zebEPXwJNJ2aEJNkkDplBSBUa/FbHVyJLeMTg0sLhfM+Slw7NSPb0dU8oqCa8WPainFtmkxto3fe/fnMY6YiX7ANBRNcI0ICeFrEqiIkOMdUWnCZoSBotVo6N4+iu0HC9mTUdTwQCXIl+BG+ymZ1lPsrbUn0rrKC7FtXIx9229gd7fZvT/PP9FEy5JjIUACFRGCMpuxa3Ig9egUw/aDhezOKOKEwR0bdJ9gTqSFyoJvZRYHDqfLZ7tT5xe37gDOVZqHbcN32Lf/CU73tJcmvjOGIWeg6z5cVvMIcYxmBSqvvfYaf//9NwsWLPBedv/99/O///2vyu06duzIr7/+CoDL5eLFF1/kf//7HyUlJYwYMYIHHniAzp07N6cpQgBgd7jIKXT/Mm1KOfpA8uSpNKZCrbeGSpBO/USG6VEUUFUoM9uJ8VE/PDkqra2GiqsoG9v6Rdh3LQGXOwlak5SKccgZaLsMkgBFiBo0OVD54IMPeO655xg+fHiVy3fs2ME111zDxRdf7L1Mq62cY3355Zf58MMPeeKJJ0hJSeHpp5/miiuu4JtvvsFgCM5fhaL1OFpQjktVCTNog26UwVP4LSu/nFKzvUF733hHVFrpyEF9NBqFKJOe4nI7xeW+C1Q8q35ayz4/zvwMbOu/wbFnhTsqA7Qd+mIYcjraDn0lQBGiDo0OVLKzs3nwwQdZsWIF3bp1q3Kdqqrs3r2bq666isTE6vOrNpuNt99+m9tvv51JkyYB8OyzzzJhwgR+/PFHTjvttCZ1QggPT35K+/iIoPvyjzTpSYkLJyu/nD0ZRQzqkVDvfTzJtMFYPt8jKtxQEaj4Lk8lv5XkqDhz9mNb9w2O/Wu8l2k7p2Mccjpa2ZdHiAZpdKCyZcsW9Ho9X3/9NS+99BIZGRne6w4ePEh5eTmpqak13nf79u2UlZUxZswY72XR0dH069ePVatWNStQ0el8u7+itmKuXOujOfPWLlT6m11QWZG2tvdEa+5rz04xZOWXsy+zmGF9kuq9vWdEJT4mrMb+tua+ekRHGMjILaPM4mj251ir1VBusWO2uqdVEtqZfP7d0BCq3UL5H/Ox7VzqvUyfOoKwYaejS+zmk8cIhtfWV9pSX6Ht9bc+jQ5UJk+ezOTJk2u8bufOnQAsWLCAP//8E41Gw8SJE7nllluIiooiKysLgPbt21e5X1JSkve6ptBoFGJj/ZOPEB3tnx1zW6tg729eiftXeVrndvW+J1pjXwf1TuKvjZnszy6tt/2qqnoDlW6dYomNrT15uDX21SMhNhwOFOBU8cnn+FB2CeAu9tYhJabZx2ssW85BshfOxZ6XAYqGyP7jaTd2FoZE/+ThtebX1tfaUl+h7fW3Nj5d9bNz5040Gg1JSUm8+uqrHDx4kKeeeopdu3bx7rvvYjabAarlohiNRoqKmrZzLIDLpVJcXN6sth9Pq9UQHW2iuNiM0xn6G36FSn/3Z7rfR7ERegoKymq8TWvua4dY9xfTjgMF5OaVoNXU/ouqpNyGw+nOd8DprLG/rbmvHmF6dx+zcktrfc0aSqvVkFvo/p5pF2Vs9vEay7pzKeW/vw0OG0pELJHTrkPXvjdlQJmP2xIMr62vtKW+Qtvpb3S0qUGjRj4NVK699louvPBCYmNjAejVqxeJiYn84x//YNOmTYSFuTPwbTab998AVqsVk6l5kaO/dg91Ol1tamfSYO6vS1XJzHUHrEntTPX2ozX2NSnWhMnoLvy2/0gJXVOiar1tToH7hBxp0qNQ92egNfbVI6Jit+iiUqtP2phX5H5eYiONLdZn1WHDuuwjdz0UQNuxH2GTrwFTtN/b0JpfW19rS32Fttff2vh0Akyj0XiDFI+ePd0JY1lZWd4pn6NHj1a5zdGjR0lOTvZlU0QbVFhixWp3otUoJLYLziFTjaKQ6lmmfKTuUUZvIm2QrvjxiK6oTltc5psy+rlFnqXJLfO8uIpzKP/60YogRcEw9AxMJ9+OxhTdIo8vRKjzaaBy5513cumll1a5bNOmTQD06NGDPn36EBkZyYoVK7zXFxcXs3XrVkaMGOHLpog26EhFobekWJPPCocFQloH9wluT0Z9gUpw11Dx8JbRN/tm1Y9n6qcl9vlx7F9H2cIHceUeQDFGYjr5FozDZ6HUMWUnhGgcn079TJ8+neuuu44XX3yRM844g3379vHwww9z2mmnkZaWBsDFF1/M3LlziYuLo2PHjjz99NOkpKQwbdo0XzZFtEHHLk0OZj06uUdUdtcXqJQEd1Vaj+iIio0JfTWiUhGo+HNERXU5sa36HNuG7wDQJKVhmnIdmsh4vz2mEG2VTwOVk046ieeee47XX3+dN954g6ioKE4//XRuvvlm721uuukmHA4H999/PxaLhREjRvDWW2+h19df3EqIulQGKsFVOv94qe1jUICcQgvFZTaiI2oORDwjKsE+9eMZUfFVHZW8Iv/WUHGVF2L55RXvDsf6AVMxjjoPRSs7kgjhD836ZD3xxBPVLjv55JM5+eSTa72PVqvljjvu4I477mjOQwtRTVaQ7vFzvPAwHR0SIsjILWNPRhFDetW8OV2w75zs4dmY0GJzYnc40euat1uwP0dUHEe2YfnlFVRzMejDCDvhcvSpI33+OEKISjKRKkLGkRCZ+oHKcvp1Tf8E+z4/HiajDq3GXUW4pLx50z9Wm5NSs/sYvt7nx7ZpMeZFT6Gai9HEdiJi5oMSpAjRAiRQESGhzGKnuMw9wpASF9wjKgBpHetPqA2VqR9FUbzTW82d/vGUzg8zaDEZmzcy46GqKtYVn2Jd9hGoKrpe4wif+S807drXf2chRLPJpKoICZ78lNgoIyZj8L+te1SMqOzLKsHhdFVbxeR0ubyBWbAn0wJEmfQUlFibvUTZuxlhlNEnez2pLgeWP97BsWsJAIaR52AYdGrQ7SMlRDCTERUREjJDJD/FIyUunIgwHXaHi0NHS6tdX1RqQ8Vdd8WTjBrMoipGVEp8NKLii6XJqt2KefE8d5CiaAg7YQ7GwadJkCJEC5NARYSELE9+Slzw56eAezqkrjwVTyJtTKQBjSb4T5yehNpmT/1UjKg0d8WPaimlfNGTOA9tBK0B07Sb0Pee0KxjCiGaRgIVERK8S5MTQmNEBSoTamvKUwmVYm8e3qJvzUymza9IMI5txoiKqzSP8q8fxXV0LxgjCD/1DnRdBzerXUKIpgv+yXwhOGbqJwQSaT161FGhtiBEir15RIV7ir41b0SloLh5NVSc+Ycxf/9f1LIClIg4TKfchja2Y7PaJIRoHglURNCzO1wcraid0T4hNKZ+ALp3iEZRIK/YSkGJtcrqnlBZ8ePh3e+nmSMqeRWBSnxM40dUHFk7Mf/wHNjK0cR2wHTybVJpVohWQKZ+RNA7WlCOqoLJqCWmliquwSjMoKNzYiRQfVQl5KZ+fLQ82TPS1NgAzrF/HeZFT7uDlOQehJ9+rwQpQrQSEqiIoHfsHj+htiKjtoTawhAp9ubhGVEpbUagYnc4vTkujVn1Y9v+B+af5oHTjrbLIMJPvQMlLLLJ7RBC+JYEKiLohWJ+ikePWhJqPat+QmXqJ8q76seOqqpNOoZnNMWg1xIRVv+stqqqWNd+jfXPd0BV0feegGnaTSi60HhOhQgVkqMigl7lip/QyU/x8FSoPZBdUmUfnMqpn9CY6vKMqNgdLiw2Z5OK9nkClYSYsIqRtdoDHk+1WfvG7wEwDD4Nw4izQ25ETohQIIFKCFJVlZ/XHKZDfAT9u8cFujmNti+zmCWbMrHandgdLhxOteJvF3aHC7vThaPib7ujskJrKI6oJLYzER2up7jczoGsUnp0isFmd1JmcQDQLkRGVIwGLQa9BpvdRUm5rUmBSk6hO5E2oZ2pztupqopt5f+8QYpxzIUYBk5rfKOFEC1CApUQdOhoKR/9vAsFuPzUvowbGDx7kmzem8cLCzdhd7gadT+jQUtqxTRJKPEUflu3K5fdGUX06BTjHU0x6DSEh8B2AR7R4QZyiyyUlNtJim38/fdnFQPQvUPt7wNPkGLb8B0AxnGzMfQ/qUntFUK0jND5lhNenpUTKvD2om04XSoTB3UIbKMaYP3uXF7+YhMOp0q/brH06xaHXqtBp9NU/K2g12rR65TKy3UadFoNcVFhhDcgLyEYeQKVPUfceSqe/JR2kb7Zz6a1iArXk1tkafLKn71H3IFK7y41RzmqqmJb9fkxQcrFEqQIEQRC85u9jbNYnYB7HxiXqjL/++04nS5OHNopwC2r3dqdObzy5WacLpVhvRK5+sz+1Tbia6t6HLPyR1XVkCv25tGc6rR2h9O7J1KvrrEcn5/iDVLWfwuAcexFGPpPaV6DhRAtQs4EIchsdecvDEiNY9qIzgAs+HEnP606FMhm1Wr19qPeIGVk3yQJUo7TLSUKrUahqNRGXrGlMpE2RPJTPLxF35pQnfZgdilOl0pUuJ6k2Ko5KqqqYlu9sGqQMmBq8xsshGgRcjYIQWabe0TFZNRx3uQenDyqCwAf/bKLH1YcDGTTqlm+NYtXv9qC06Uyun8yV57eT4KU4xj0Wrokewq/FYdcsTePqIiKMvpNGFHxTPukdYypMh2mqiq2NV9gW/cNAMYxF0iQIkSQkTNCCLJUjKiYDFoUReGcSWmcNrYbAJ/+tptvl+4PXOOOsWRTJm98sxWXqjJuYApXnNoPrUbekjVJ61A5/VMQYsXePKJMnqmfxo+o7M2sCFQq9kfysK35EtvarwEwjr4Aw8DpzWylEKKlyVkhBJVXBCphFStCFEVh1sRUzprQHYCFf+7lq7/3Nbmwli/8teEIby/ahqrCxEEduOyUvmg0oZMY6mvH7qQcrMXeVLsFy1/vYvnzbZzZu6u9/6IjPEXfGh+o7KsYUUk9ZsWPdc2X2NZ+BYBx9PkY0iVIESIYSTJtCLLYKkZUjlu6esa47mg1Cp//4Q5UnC4XMyektvjKkd/XZfDe4h0AnDi0IxdN7YUmhFav+IMnofZgdqn3hB5MybSusgLMPzyHK+8AAPbtf6KJ64y+7yT0PceiGEzH5Kg0buqnpNzm3ZQytaJAnnnVl9jWfAmAcdR5GNJn+KgnQoiWJoFKCDJXrPoxGbTVrjt1TDd0Wg2f/Lqbb5cewOFUOXdSWou17efVh/jw510ATBneiQtO6hlSS2z9JS7aSLtIA4WltsrlyUEyouLMO4j5h+dQy/JRwqLQdhqAY99qXPmHsC5ZgHXFJ+h7jKZd0igASsyNG1HZVzHtkxIXTkSYnoK/P8OyaiEAxlH/wDDoZN92SAjRoiRQCUHmWkZUPKaP7IJWo/Dhz+7kWqdT5eLpvfzersUrD/LJr7sBmDGqC+dOSpMgpYEURaFHxxhW78jxXhYMOSqOgxsx//Iy2C1o2rXHNOMWNNFJqNaLse9ain3rb7gKj2Df/icx2//k9ug4ltl647QNQ2uou8Ksx94jxWhw0S9JwbzqCyyrvgDAMPJcDINO8Wf3hBAtQAKVEOSpoxJmqP3lnTK8M1qthgWLd/DT6kO4VJWbzh/qtzYtWrafz//YC8BpY7sGZMop2KUdE6iEG3UY9dVHzFoT29ZfsS5ZAKqKtkNfTFNvQDG692NSjBEYBkxF338Kzqyd2Lf9jmPfKjqTT2fdMso/WIe+xxj0fSehiU7CVVaAWlaAWl5Q+e+yAlzlhYzOPcqJseVojqpYjrof2zT6XHTppwaw90IIX5FAJQRVjqjUfSI7cUhHdBqF+d9v55c1hzEYdZx/ou+ngY4NUs4c350zxnWTIKUJehyzRUBrnvZRXS6sKz7BvmkxALpe4wmbcCmKtvrXjaIo6Nr3Rte+N6rlIj5+4z1G6LaTTDH2bb9h3/ZbvY8XAaCAqmjQRsQSO/ZMXD0m4WjkNgxCiNZJApUQ5F2e3IB9YCYM6oBGo/D2om18v3Q/eo3CWeO7+6wtv6/P8AYpsyamepdJi8brkhyFTqvgcKrEttJEWtVuxfLrqzgOrAPAMOJsDINPa1BgqoRFstEwhJ8KevOv6VGk5K3GsX8NuJxgMKGJiEUJj0WJiHX/OyKWYjWced8dokyJ4In/m4bJZCAmNoKCgjJ/d1UI0UIkUAlBZu/UT8OmBsYNbI/T5S61//Xf+wg36rwVbZtj1fajLPjBvbrn1DFdJUhpJr1OQ9eUKPZkFLfK/BRXeaF7ZU/uftDqCDvhCvQ9RjfqGFHhBrILzOSZutF9ykhUu7tmjKKvub+7tmRx2FlOWodo9Hr5OhMiFMknO8SoqlpvMm1NJg/rhBOFBd9v4+NfdhERpmvWrsub9+Xx+tdbUIFJgzswa2Jqk48lKvXtGseejGJS4sMD3ZQqnPmHMH//rHtljzGSsOn/hy6lZ6OPExXuqU7rXvlTW4Di4alI2/24Qm9CiNAhgUqIsdldeOpomepIpq3JuSf1JCe/jB9WHOSd77YTHqZjSM/ERrdhT0YRLy7chNOlMqJPEhdP6y05KT5y6piupLaPpl+3mncIDgTHoU2Yf34J7BaUmBTCZ9yCJia5SceKjqiopdLAMvqepcmp7SVQESJUSWXaEOOpSqtRFAz6xr28iqJw/pSejBuQgktVeeXLLew4WNCoY2TklPLc/zZgs7vo3z2OK0/vJxVnfcio1zK4ZwKGVrDiR1Vd2Db/hPmHZ8FuQdu+NxFn3t/kIAUqd1BuSHVau8PFwewSAFJlREWIkCWBSoixHLPipymjGBpF4dJT+jCkZwIOp4vnP9vIgaySBt03t9DMfz9ZT5nFQVqHaK6fOUA2GAxRzryDlH/9GNalH4DqQtdzLKZTbkcJi2zWcaPDG74x4eGcUhxOlUiTnsR2Dau5IoQIPnIWCTHmBtRQqY9Wo+GaM/vTu3M7LDYnz3y6nqz88jrvU1RmY+4n6ykstdExIYL/O3dQs9ogWifVZsay9EPKFz6IK3s36MMwjr2IsElXomj1zT6+Z0SlpKz+ERVvfkr7aJlaFCKENStQee2115g9e3aVy3799VfOPvtshgwZwuTJk3nyySexWCze69esWUPv3r2r/VmxYkVzmiIqNLSGSn30Oi03nZNO1+QoSsrt/PfjdeQXW2q8bbnFwbOfrOdogZmEmDBuPW8wkabmn7RE66GqKvY9Kyj79B7sm38EVUWXOpKIfzyOYcBUnwUKnhGVhkz97D1SBMi0jxChrsk/eT/44AOee+45hg8f7r1s9erV3HDDDdx0003MmDGDAwcO8MADD1BYWMjjjz8OwI4dO+jSpQsffvhhlePFxMQgms9y3M7JzWEy6rjlH4N4/IO1ZOeX899P1nP3RUO9v3oBbHYn8z7bwMGjpUSH67nt/MFBt6uvqJurMAvLkgU4M7YAoEQnEzZ+NrpOA3z+WFEVybQNmfrZmyn5KUK0BY0eUcnOzuaaa65h7ty5dOvWrcp1H3/8MaNGjeKaa66hW7dunHDCCdxyyy1888032GzuX0g7d+6kR48eJCYmVvljMLTOAlbBpnJDQt9Mu0RHGLj9PHfwkZlXznP/24C5IhhyOF288uVmdh4uwmTUcut5g0mObV3LZkXTqQ4b1tULKfvsfneQotVhGDaTiHP+45cgBfDuoFxmtuN01V5ZtsxiJ7tiOrK7rPgRIqQ1+my2ZcsW9Ho9X3/9NS+99BIZGRne6y6//HI0mqqxj0ajwW63U1paSlxcHDt27GDYsGHNb/lxdDrfpttoK5JAtUGWDGpzuAOV8DBdo56TuvqbHB/OnRcN5dF3V7Mvs4SXvtjMrecNYv7329mwJw+9TsOt5w0mtWNwjIoF62vbFE3tq/3ABsr/WoCr2L15jq5LOuETZqNtxoqehmgXZUQBVMBicxITWfNX1IHsUgCSY01VthOQ1zY0taW+Qtvrb30aHahMnjyZyZMn13hdv379qvzfbrczf/58BgwYQFxcHAC7du0iNjaWWbNmkZ2dTa9evbjllltIT09vQvPdNBqF2NiIJt+/LtHRQbaaoCJQbBcd1qTnpLb+xsZG8NBVY7j/1SVs3Z/PPa8vJ6fAjFajcM8/RzCiX0qzmh0IQffaNkND++ooziP3x7co3+HOGdNGxRE/7XIieo9usYTVqAgDxWU20OlqfQ9nFhwGoG/3+BpvI69taGpLfYW219/a+G1ZhsPh4M4772TXrl188MEHAGRmZlJSUkJ5eTn3338/Wq2W999/n4svvpiFCxfSo0ePJj2Wy6VSXFz3qpTG0mo1REebKC4243QGz+Zm+UVmADSojdrvpCH9TYwycNM5g/jvx+vIKXA/zpWn96NH+6ig2lslWF/bpmhMX+2HNlP208uollJQNBgHTcc0/CzsBhOFhb79fNUlyqSnuMzG4cwiYsJqTgrfvDsXgE4J4VXee/Lahqa21FdoO/2NjjY1aNTIL4FKaWkpN998MytXruTFF1/0jpa0b9+eVatWYTKZ0Ovd2f0DBw5k69atLFiwgIceeqjJj+mvnVKdTldQ7cJabnYnIRp12ia1u77+9u7cjmvPHMDnf+5l6vBOjOybHFTPz7GC7bVtjrr6qqoqtg2LsK36HFQVTUI3wibNQRvXGSdACz9HnjL6hSXWGtusqip7MtwrfrqmRNV4G3ltQ1Nb6iu0vf7WxueBytGjR7nyyivJyMjgrbfeYsSIEVWuj46umvim0WhIS0sjOzvb101pk8p9uOqnNkN6JTKkV+NL64vWR7WZsfz+pnuXYkDfewLGcbNRdIFLbo+spzptbpGFUrMdrUahS1JUSzZNCBEAPs3UKSoq4p///Cf5+fl88MEH1YKUP//8kyFDhnDo0CHvZQ6Hg+3btzd52kdUZbFVrPppZh0VEfqchUco//Jhd5Ci0WKccCnGiZcHNEiBY6vT1hyoeAq9dUmORO/jJHohROvj05/djz/+OIcOHeLNN98kLi6OnJwc73VxcXEMHTqU2NhY7rrrLu699170ej2vv/46hYWFXHrppb5sSpvlWTrsq+XJIjTZ963B8vsb7o0EI2IxTb0BbVJaoJsFVC5RLi6ruZaKJ1BJbR8cq8yEEM3js7OZ0+nku+++w263889//rPa9b/88gudOnVi/vz5zJ07lzlz5mC1Whk2bBjvv/8+CQkJvmpKm+ato+LHqR8RvFSXC9vqhdjWfwuAtn1vwk66Dk146znpVxZ9q3lExbtjshR6E6JNaNbZ7IknnvD+W6vVsnHjxnrv06VLF+bNm9echxV18GxKGCZTP+I4qqUU8y+veCvM6gdOxzjqXBRN6wpqo0y1b0zocLo4ULFjcncJVIRoE1rXN5RoNpn6ETVx5Oyn7PvnUUvzQGcgbOLl6HuMDnSzahQdUXsy7eGcUuwOFxFhOpJjpcaEEG2BnM1CiKqqxyTTyksr3Eo2/kbJd6+B044SnYRp2o1o4zoHulm1iqojmXaf7JgsRJsjZ7MQYne4cLpUAMIMMvUjwLzqSyyrFgKg7TII04lXoRj9U8XZVzwjKmarE7vDVWVlz95jAhUhRNsggUoIMVeMpiiAUQKVNs++b403SAkbfha6IWegKK1/OW+4UYdWo+B0qZSU24iLDvNet1cSaYVoc1r/t5ZoMLO1MpFWI8PibZqz8Ih7+TEQM/I0TCNnBUWQAqAoCpHh1RNqyy0OMvMqdkyWQEWINiM4vrlEg3gTaSU/pU1TbWYsP74Adgu6Dn2Imzw70E1qtOgaqtPuy3KPpiTEhHmvF0KEPglUQohFVvy0earqwvL7m7gKM1EiYomYdgOKNvjeD57qtMVllYGKt9CbjKYI0aZIoBJCPDkqUkOl7bKt/66iJL4O09Qb0YQH50k9KtxT9K1y6mefN1BpPcXphBD+J4FKCJEaKm2b49Am9w7IgHH8bLRJqQFuUdNVBiruERVVVSsTaWXFjxBtigQqIcTiHVGRQKWtcRXnYP71VUBF3+cEDH1OCHSTmiU6omLqpyJQySu2UFxmc++YnBwZyKYJIVqYBCohpHJERaZ+2hLVYcX80zywlqFJTMU47uJAN6nZjp/62ZfpLpvfKSkSg17e30K0JRKohBCzTVb9tDWqqmL5cz6uvEMopmhMU29A0eoD3axmO7467d4jRYBM+wjRFkmgEkIsFTsnS1XatsO+5Wccu5eBonHvghwZF+gm+YR3eXKZe0RFVvwI0XZJoBJCZESlbXFk7sC67GMAjKPPQ9ehT4Bb5DtREZXJtE6XiwNZ7qkfCVSEaHskUAkhZosEKm2Fq6wAy88vgepE12M0+gHTAt0kn/LUUbE5XOw9UozN4cJk1JEcFx7glgkhWpoEKiHELDsntwmq0475pxdRzcVo4joTNuGykNtJ2KjXejcjXL87F4Du7aNkawgh2iAJVEKIRVb9tAnWpR/gOroHDOGYpt2IojcGukk+pyiKd1Rl4+48QKZ9hGir5Kd3CPHkqEgdldCjWstwHFiHfe8qnAc3AAqmydegiU4KdNP8JircQF6xlYzcMgC6y4ofIdokOaOFEHPFqh8ZUQkNLnMxjv1rcexbjTNjG6hO73WGkeeg65IewNb5X3RE1Y0HpXS+EG2TBCohxCKrfoKeq6wAx7417uAkaweoqvc6TVwndN2Ho+s+Am1cxwC2smVEmSrrwcRHhxETITsmC9EWyRktRNgdLhxO90ktTPb6CSquklwc+1Zj37caV/buKtdpErqh6z4cfffhaNqlBKiFgRF1TGDSXfJThGiz5IwWIjz5KSAF34KFqqrY1i/CtvrzqiMnyT3Qdx+GrttwNNGJAWxhYHmKvoFUpBWiLZNAJUR4VvwYDVo0GlnC2dqpTgeWv97FsfMvALQpvdCljkDXbVjIVJdtLk8ZfZAVP0K0ZRKohAhJpA0eqrUM808v4jyyDRQF49iLMPSfEuhmtTqejQk1ikLXlKgAt0YIESgSqIQI787JkkjbqrmKj2L+4VlchZmgD8N00rXougwKdLNapc5Jkei0Gnp3aYdRdkwWos2Ss1qIkH1+Wj9n9m7Mi59HtZSgRMRhmnEz2vgugW5WqxUbZeSZG8ZJzpUQbZyc1UKERaZ+WjX7nhVYfn8DnA408V0xzbgZTURsoJvV6kUes0RZCNE2SaASIqQqbevkXtnzLbZVnwOg7TIY00nXoOjDAtwyIYQIDnJWCxHeHBWpodJquFf2zMex828A9AOmYRx9PopGttgSQoiGkrNaiLBU7JwcZpSpn9ag+sqeizH0PynQzRJCiKAjgUqIkBGV1kNW9gghhO/IWS1EeOuoSI5KQLmKj1L+5X9kZY8QQvhIsybLX3vtNWbPnl3lsm3btnHxxRczePBgJk+ezHvvvVflepfLxbx585gwYQKDBw/myiuv5NChQ81phqByQ0KZ+gkcVVWx/DUf1VKCJr4z4Wf9S4IUIYRopiYHKh988AHPPfdclcsKCgq47LLL6NKlC59//jnXX389c+fO5fPPP/fe5uWXX+bDDz/kP//5Dx9//DEul4srrrgCm83W5E4ImfppDRw7/8aZsRW0ekxTbpDlx0II4QONPqtlZ2fz4IMPsmLFCrp161bluk8//RS9Xs/DDz+MTqcjLS2NAwcO8Prrr3P22Wdjs9l4++23uf3225k0aRIAzz77LBMmTODHH3/ktNNO80Wf2qTKqR8ZUQkEV3kRluUfA2AYNhNNTHKAWySEEKGh0YHKli1b0Ov1fP3117z00ktkZGR4r1u9ejUjR45Ep6s87OjRo3nttdfIzc3lyJEjlJWVMWbMGO/10dHR9OvXj1WrVjUrUNHpfLvkU6vVVPm7tfNM/USGG5r0XARbf5vDH30tXf4RWMvQJnQhfOjJrWYJclt6XaFt9Vf6GrraWn/r0+hAZfLkyUyePLnG67KysujVq1eVy5KSkgDIzMwkKysLgPbt21e7jee6ptBoFGJjI5p8/7pER5v8clxfs9pdACQnRjXruQiW/vqCr/patms19t3LQdGQcsYNGONb306/bel1hbbVX+lr6Gpr/a2NTxMaLBYLBoOhymVGoxEAq9WK2WwGqPE2RUVFTX5cl0uluLi8yfeviVarITraRHGxGafT5dNj+0OZxQ6A3WKjoKCs0fcPtv42hy/7qtrMFC16DQDjoOmUh6VQ3oTn31/a0usKbau/0tfQ1Vb6Gx1tatCokU8DlbCwsGpJsVarFYDw8HDCwtxlw202m/ffntuYTM2LHB0O/7yYTqfLb8f2FYfThb2ijXqdplntDYb++oov+mpZ9j/UsnyUqET0Q89qtc9dW3pdoW31V/oautpaf2vj0wmwlJQUjh49WuUyz/+Tk5O9Uz413SY5WZIPm8pTlRaQnWZbkDN7N/YtvwAQNuFSFJ0xwC0SQojQ49NAZcSIEaxZswans/LEuXz5crp37058fDx9+vQhMjKSFStWeK8vLi5m69atjBgxwpdNaVM8S5MNeg3aVpLEGepUpwPLn28DKrpe49B16h/oJgkhREjy6Vnt7LPPprS0lPvuu4/du3ezcOFC5s+fz9VXXw24c1Muvvhi5s6dyy+//ML27du55ZZbSElJYdq0ab5sSpsiNVRanm39IlwFR1DCoggbfUGgmyOEECHLp2e2+Ph43nzzTR599FFmzpxJYmIid955JzNnzvTe5qabbsLhcHD//fdjsVgYMWIEb731Fnq93pdNaVMqNySUQKUlOAuOYFv3DQDGsRehhEUGuEVCCBG6mnVme+KJJ6pdlp6ezieffFLrfbRaLXfccQd33HFHcx5aHKPcO6Ii+Sn+pqourH++Ay4H2i6D0KWNCnSThBAipElCQwiweAIVGVHxO/u233Fm7wJ9GGHjL0FRlEA3SQghQpoEKiHAbJOdk1uCqzQf64pPATCOOBtNZHyAWySEEKFPApUQYJGpH79TVRXL3++B3YImKQ19v5MC3SQhhGgTJFAJAeaKfX4kmdZ/HPtW4Ty4HjRawiZe3mr28hFCiFAn37YhQHZO9i/VWoZ1yfsAGAafhjauY4BbJIQQbYcEKiHAInVU/Mq6/BNUczGadu0xDGn6Dt9CCCEaTwKVEGCWOip+Y9v+B/YdfwJgnHgZilbq/QghREuSQCUEmCWZ1i/s+1Zj/Ws+AIYhp6NL6RXYBgkhRBskgUoIsEgyrc85MrZi+eVVUFX0fSZiGD4r0E0SQog2SQKVEFDuSaaVERWfcObsw/zjPHA50HUbhnH8pVLYTQghAkQClRAglWl9x1WYifn7Z8BuQduhL2EnXSNLkYUQIoDkGzgEeOqoSKDSPK7SPMoXPY1qKUGT2B3TtJskeVYIIQJMApUg53S5sNldgAQqzaFaSjF/91/Usnw0MSmYZtyCYjAFullCCNHmSaAS5CwVS5MBwiRHpUlUu4Xy75/BVXgEJSIO06l3oDFFB7pZQgghkEAl6HmWJut1GnRaeTkbS3XaMf/4Aq6cvSjGSEyn3C6bDQohRCsiZ7YgZ5EVP02mulxYfnsdZ8YW0BkxnXwr2tgOgW6WEEKIY0igEuRkQ8KmUVWV8j/fxbF3FWi0mKbdhDYpNdDNEkIIcRwJVIKcd0NC2eenUQr++Bjb1t8AhbDJV6Pr1D/QTRJCCFEDObsFOYt3abJM/TSUZcNizEs+A8A4/hL0qSMD3CIhhBC1kUAlyJVXJNOGyYhKgzhz92Ne+iEAYSPPQd/vxAC3SAghRF1k6ifIeZNpJUelXqrLieXPd0BVieg7lrBhpwe6SUIIIeohgUqQ8+6cLFM/9bJv/hlX7gEUYzjx0+bI/j1CCBEEJFAJclI+v2FcJblYVy8EwDTmPHSR7QLbICGEEA0igUqQ80z9SFXa2qmqimXJAnBY0ab0wtD3hEA3SQghRANJoBLkZESlfo59q3Ae3AAaLcYJl6Io8rYXQohgId/YQc7iyVGRVT81Uq1lWJd8AIBh8GlSeVYIIYKMBCpBzlyxKWGYJNPWyLryM1RzEZqYFAyDTw10c4QQQjSSBCpBziwjKrVyZO3Cvu03APeUj84Q4BYJIYRoLAlUglzl8mQJVI6lOh1Y/3oHAH3vCeg69Alwi4QQQjSFBCpBTqZ+ambb8B2ugiMoYVEYR50X6OYIIYRoIglUgpjLpWK1SWXa47mKsrCt+xoA49gLUcIiA9wiIYQQTeXTs9uKFSu45JJLaryuU6dO/PLLL7zyyis899xz1a7fsWOHL5vSJlgqghSQHBUPVVWx/PUuOB1oOw1AlzY60E0SQgjRDD49uw0ZMoS///67ymXr16/nxhtv5LrrrgPcAcmZZ57JHXfc4cuHbpM8OyfrtAp6nQyOATh2LcF5ZBtoDYSNv0TK5AshRJDzaaBiMBhITEz0/r+8vJzHH3+cmTNncvbZZwOwc+dO/vGPf1S5nWgas+ycXIXLXIx12ccAGIadhSY6KcAtEkII0Vx+/Rn+6quvYjabueuuuwCw2Wzs37+f1NRUfz5sm2H25qdIIi2AdfnHqNZSNHGdMaRPC3RzhBBC+IDfforn5+czf/58brvtNtq1awfA7t27cTqdLF68mEcffRSr1cqIESO44447SEpq3q9fnY+nPrRaTZW/WyObwwW4E2mb2/9g6G9d7Ic249i1FFCIOPFydIbaa6YEe18boy31FdpWf6Wvoaut9bc+fgtUPvzwQ6KiojjvvMqloTt37gTAZDLx/PPPk5eXxzPPPMMll1zCl19+SVhYWJMeS6NRiI2N8Em7jxcdbfLLcX1Bqy8EICrC6LP+t+b+1sZlt3L47/cAiB5+Mgl90ht0v2Dsa1O1pb5C2+qv9DV0tbX+1sZvgcqXX37JWWedVSX4OOuss5g4cSJxcXHey3r27MnEiRP59ddfOeWUU5r0WC6XSnFxebPbfCytVkN0tIniYjNOp8unx/aV3LwyAPRahYKCsmYdKxj6W5vyZZ/gKMhCiYhFM/jMep+LYO5rY7WlvkLb6q/0NXS1lf5GR5saNGrkl0Bl+/btHDp0iNNPP73adccGKQBJSUm0a9eOrKysZj2mw+GfF9PpdPnt2M1VarYDEKbX+qyNrbm/NbFt+x3rukUAGMddjFNjhAa2P9j62hxtqa/QtvorfQ1dba2/tfHLBNjq1auJj4+nT5+qZcufffZZpk+fjqqq3ssOHz5MQUEBPXr08EdTQpp31U8bLfZm370c61/vAmAYdAr6bsMC3CIhhBC+5pdAZevWrfTu3bva5VOnTiUjI4N///vf7Nu3j1WrVnHjjTcydOhQJkyY4I+mhDRLG1714ziwHstvbwAq+r4nYhh5bqCbJIQQwg/8Eqjk5OR4V/oca8CAAbzxxhvs2LGDWbNmccMNN9C3b19effVVKczVBG1152THkW2Yf34RVCe6HmMwjp8t7x8hhAhRfjnDvfHGG7VeN2bMGMaMGeOPh21zzG1wnx/n0T2YFz8PTge6rkMImzQHRZElfEIIEarkGz6IWbyVadvG1I8z7xDl3z8Ddgvajv0IO+laFE3bCdKEEKItkkAliJkr9vppCyMqrqIszN89DdYyNMk9ME27CUVXe1E3IYQQoUEClSBmsVZM/YT4iIqrNI/yRU+jmovRxHcmfMYtKPqmFQcUQggRXCRQCWKeEZVQXp7sKi9yBymleSgxKZhOvh3F6J8qxEIIIVofCVSCmNka2sm0qrUM8/dzUYuyUCLjCT/1DjThMYFulhBCiBYkgUqQcqmqN5k2FKd+VLuF8u+fwZV3CMUU7Q5SIuMD3SwhhBAtTAKVIGW1OfHU9w21qR/VYcP84zxcR/eAMQLTKXegiUkJdLOEEEIEgAQqQcpTlVarUTDoQudlVFUXlt9ex5mxFXRGwk++FW1850A3SwghRICEzhmujTEfU0MllKqy2lZ+hmPfatDoME3/P7RJaYFukhBCiACSQCVIhWINFdv2P7Bt+A6AsBMuR9exX4BbJIQQItAkUAlSnhoqYSGyz48jYyvWv94DwDD0TPQ9xwa4RUIIIVoDCVSClHdDwhDYOdlZeATzTxWbDKaNxjDsrEA3SQghRCshgUqQCpWpH5elBPP3z4KtHE1yD8JOuDykcm6EEEI0jwQqQapy6id4R1RUpx3L4nmoJTkoUYmyf48QQohqJFAJUsE+oqKqKpY/3saZvQsMJkwzbkZjig50s4QQQrQyEqgEKW+OSpAm09rWfo1j9zJQNJim3IA2tmOgmySEEKIVkkAlSFXu8xN8Uz/23cuxrfkCAOP4S9B16h/gFgkhhGitJFAJUpYg3TnZmbULyx9vAqBPn4Gh76TANkgIIUSrJoFKkPKOqATR1I+r+CjmH+eB04Gu6xCMI/8R6CYJIYRo5SRQCVKVybTBMfWjWssw//AcqqUETXxXwiZfg6KRt58QQoi6yZkiSFmswTP1o7ocmH9+GVfhEZSIWEwzbkbRGwPdLCGEEEFAApUgFSxTP6qqYl3yPs6MLaAzYpp+M5qI2EA3SwghRJCQQCVIWYJk6se+5Wfs234HFEyTr0Gb0DXQTRJCCBFEJFAJQqqqekdUWvOmhI5DG7Eu+xAA46h/oOs2JMAtEkIIEWwkUAlCNrsLl6oCrXdExVlwBPPPr4Cqous1AX36jEA3SQghRBCSQCUIeVb8KAoY9a0vUFEtpZgXPwd2M9qUXoRNuEQ2GhRCCNEkEqgEoWPL57e2AEB1OjD/9AJq8VGUqATCpt6AotUHullCCCGClAQqQchia53l890rfBbgzNwB+jD3Ch/ZaFAIIUQzSKAShMyttIaKffOP2Lf/AYqC6aRr0cZ1CnSThBBCBDkJVIJQa6yh4ji4AevyjwEwjjofXZdBAW6REEKIUCCBShCq3JCwdUz9OPMzMP/iXuGj7z0R/cBpgW6SEEKIECGBShA6Npk20FyWkooVPha07XtjHC8rfIQQQviOzwOV7OxsevfuXe3PwoULAdi2bRsXX3wxgwcPZvLkybz33nu+bkLIM7eSZFrV6cDy4wuoJTkoUYkVK3wCHzwJIYQIHT4/q2zfvh2j0cjPP/9c5Zd1VFQUBQUFXHbZZUyePJmHHnqI9evX89BDDxEREcHZZ5/t66aELO+GhAEcUVFVFctf7+LM2gl6E6YZN6MJiwpYe4QQQoQmn5/pdu7cSbdu3UhKSqp23bvvvoter+fhhx9Gp9ORlpbGgQMHeP311yVQaQTv1E8AV/3YN/2AY+df7hU+U65FG9sxYG0RQggRunw+9bNjxw7S0tJqvG716tWMHDkSna7yBDt69Gj2799Pbm6ur5sSsrxTP4bATP04Dq7HuvxTAIyjL0DXOT0g7RBCCBH6/DKiEhsby0UXXcS+ffvo2rUr1157LRMnTiQrK4tevXpVub1n5CUzM5OEhIQmP65O59uYS6vVVPm7NfEUfIsI1/us3w3trzP/MOZfXgVUDP1OxDR4etAlz7bm19bX2lJfoW31V/oautpaf+vj00DF4XCwd+9eevTowd13301kZCSLFi3iqquu4p133sFisWAwGKrcx2g0AmC1Wpv8uBqNQmxsRLPaXpvoaJNfjtscDpd7Q8LEuEif97uu/jrLS8j44XmwWwjr0p/2Z1wT1MmzrfG19Ze21FdoW/2Vvoauttbf2vj0LKPT6VixYgVarZawsDAABgwYwK5du3jrrbcICwvDZrNVuY8nQAkPD2/y47pcKsXF5U1veA20Wg3R0SaKi804nS6fHru5Ssrcz5nT7qCgoMwnx6yvv6rTQek3T+MozEYTnYjxpOsoLLYCTQ8wA6U1v7a+1pb6Cm2rv9LX0NVW+hsdbWrQqJHPfw5HRFT/hd+zZ0/+/vtvUlJSOHr0aJXrPP9PTk5u1uM6HP55MZ1Ol9+O3VTlFncyrUGn8XnbauqvqqpY/34Px5FtoA8jbNrNuPQRuFrZ89JYrfG19Ze21FdoW/2Vvoauttbf2vh0AmzXrl0MHTqUFStWVLl88+bN9OjRgxEjRrBmzRqcTqf3uuXLl9O9e3fi4+N92ZSQ5slRaam9fuxbf8G+7XdAwTT5GrRxssJHCCFEy/BpoJKWlkZqaioPP/wwq1evZs+ePTz++OOsX7+ea6+9lrPPPpvS0lLuu+8+du/ezcKFC5k/fz5XX321L5sR0lRVPaYyrf9X/TgytmJd+iEAhpHnous62O+PKYQQQnj49Ce5RqPh1Vdf5b///S8333wzxcXF9OvXj3feece72ufNN9/k0UcfZebMmSQmJnLnnXcyc+ZMXzYjpDmcLpwVybT+rqPiKsrC/PNLoLrQ9RyLYdDJfn08IYQQ4ng+P9MlJCTw+OOP13p9eno6n3zyia8fts3w7JwMYPTjiIpqK8e8+HmwlqFJSiNswqVBtwxZCCFE8JNF2kHG7C2fr0Xjp8BBdbkw//IKrsJMlIg4TNNuRNEZ6r+jEEII4WMSqAQZs83/5fOtKz7BeWgTaA2Ypt+EJryd3x5LCCGEqIsEKkHGM/Xjr0DFuu1P7JsWAxB24hVoE7r55XGEEEKIhpBAJchY/Ljix3JoO+V/vAOAYeiZ6FNH+vwxhBBCiMYI3vrnbZRn6sfXNVScJblkff4kuJzoug/HMOxMnx5fCCGEaAoJVIKMd+rHhyMqqt1K+XfP4SovRpvQhbBJV6IoMtgmhBAi8ORsFGQsfhhRsS7/GGfeQbQR7Yg8+WYUvdFnxxZCCCGaQwKVIFM5ouKbQMVxaBP2bb8BkHTm/6GJSvDJcYUQQghfkEAlyFQuT27+1I9qLcPyx1sAGAdOxdQ9vdnHFEIIIXxJApUgY/EWfGv+iIplyfuo5YUoMSmYRv+j2ccTQgghfE0ClSBTWUeleSMq9n2rcexeBoqCadIVkpcihBCiVZJAJch4d05uRjKtq7wI61/vAmAYdCra5B4+aZsQQgjhaxKoBJnmltBXVRXrX/NRLSVo4jpLvRQhhBCtmgQqQcbSzFU/jl1LcBxYBxotYSdehaLV+7J5QgghhE9JoBJkKivTNj5HxVWah2XJBwAYhs1EG9/Zp20TQgghfE0ClSDT1DoqqurC8sfbYDejSUrDMOhkfzRPCCGE8CkJVIKI3eHC4XQBjV/1Y9/6K86MLaA1YDrxShSN7zc1FEIIIXxNApUg4imfD42ro+IqysK6/FMAjKP+gSYmxedtE0IIIfxBApUgYra5p32Mei0ajdKg+6guF+bf3wSnDW2Hvuj7T/ZnE4UQQgifkkAliJgtjU+ktW38Dlf2btCbCJt0heyKLIQQIqjIWSuIeKZ+GppI68w7hG31FwCEjb0QTWS839omhBBC+IMEKkGksnx+/YGK6nRg+f11cDnRdR2Crtd4fzdPCCGE8DkJVIJIY3ZOtq39ClfeIRRjJMYJl6IoDctpEUIIIVoTCVSCiGfn5Pqmfpy5B7Ct/xYA44R/ogmP8XvbhBBCCH+QQCWIeFb91JVMq6oq1mUfgqqiSx2BPnVESzVPCCGE8DkJVIKIuQEjKo59q3Fm7gCtAePo81uqaUIIIYRfNG1nOxEQng0Jw2pJplUdNqzLPwbAMOhkWeUjRJByuVw4nY56bqNgsWix2aw4nWoLtSww2lJfITT6q9Xq0Gh8MxYigUoQqS+Z1rbxB9TSPJSIOAyDTmnJpgkhfEBVVYqL8zGbSxt0+9xcDS6Xy8+tah3aUl8hNPprMkUSHR3X7MUcEqgEkbqmflxlBZUJtKPORdEbW7RtQojm8wQpkZGxGAzGer/gtVolaH9xN1Zb6isEd39VVcVms1JaWgBATEzzRvclUAkinkClpmRa68r/gcOGJrkHurTRLd00IUQzuVxOb5ASGRndoPvodBocjuD+1d1QbamvEPz9NRjcP5ZLSwuIiopt1jSQJNMGEc+qn+NHVJzZu3HsWgpA2JgLpWaKEEHI6XR/vj1f8EIEO897ub58q/pIoBJEvHVUjkmmVVUXlmUfAqDrNR5tUmpA2iaE8A35oSFCha/eyz6f+iksLOSZZ57h999/p7S0lN69e3PbbbcxfPhwAC677DKWLl1a5T4jR45kwYIFvm5KyPGOqBwTqDh2LcN1dC/owzCOPCdQTRNCCCH8wueByq233kpOTg7PPPMM8fHxLFiwgDlz5vDFF1+QmprKjh07+Pe//82UKVO899Hr9b5uRkiqrEzrzlFR7RZ3bgpgGHwamvB2gWqaEEII4Rc+nfo5cOAAS5Ys4d///jfDhw+ne/fu/Otf/yIpKYlvvvmGvLw88vLyGDRoEImJid4/7dq182UzQpLD6cJWkVjlqaNiW78ItbwQJSoRw8BpgWyeEEIEpRtuuIpHH/13oJsh6uDTQCU2NpbXX3+dgQMHei9TFAVFUSguLmbHjh0oikL37t19+bBtgqVi2gcgzKDFVZKDbeP3ABhHn4eiMwSqaUIIIYTf+HTqJzo6mhNOOKHKZYsXL+bAgQPce++97Ny5k6ioKB5++GGWLFlCeHg4M2bM4LrrrsNgaN6JVqfzbV6wVqup8neg2Z3u0RSDTkOYUUfp7/8DpwNdx76E9RjR7KSl1tZff5K+hq5g7q/L1bjPsOcjryigBme5jQZrS32F0OuvVqs06xzt1zoqa9eu5Z577mHatGlMmjSJe++9F6vVSnp6Opdddhnbtm3jqaee4siRIzz11FNNfhyNRiE2NsKHLa8UHW3yy3Ebq9Dszk8JN+kJK95PwZ6VoGhIPvkKjHGRPnuc1tLfliB9DV3B2F+LRUturqbGL3VVVbHZq9fUcDid1S7zNYNe0+gfQqNHD2XOnCtZtOgb7HYHr7zyJu3bt+e1115m8eLvKC0tJTU1jauuupZRo8awe/cuLr74PObP/4A+ffoCcNddt7F69Sp+/PE3tFotLpeLU0+dwv/9322cfPKpfPXVF3z66UccPnwIRVHo3bsPN998O3379gPgrLNOZfLkKSxd+jcFBQU8/vjTDBgwkJdfnsfixd9js9mZOfNsQEVRKp/zDz54j4ULP+Po0WwSEhI5/fQzueyyKwKyGisYA+5juVwKGo2GmJhwwsLCmnwcvwUqP//8M7fffjtDhw5l7ty5ADz88MPcddddxMTEANCrVy/0ej233HILd955JwkJCU16LJdLpbi43GdtB9i9ejm2Dd/TPjWViE690Cb3QBOVELClg9k57pLaYXqFoz+8CYCh3yTKDYmUF5Q1+/harYboaBPFxWaczuAtMtQQ0tfQFcz9tdmsFXv8qFUKfamqyuPvr2V3RlFA2tWjUwz3XDS00d99n3/+P+bOnYfD4aRDh078+9/3ceDAPv71r/+QmJjEkiV/cttt/8djj81l7NjxtG/fgeXLl9GjR2+cTidr1qyivLyMrVu30q9ff7Zt20xJSQmjRo3jl19+4b//fZK77rqfQYOGkJuby3PPPc2jjz7M/Pkfetvw2Wef8OSTzxIVFUVqag/mzn2SJUv+4t57HyQ5uT3vvfc269evo337jjgcLv7++0/mz3+bhx9+jM6du7Fly0YeecR92+nTW25bEkVxv5edTldQj6g4nSoul4uionLM5upBdXS0qUHBmF8Clffff59HH32UGTNm8OSTT3qndXQ6nTdI8ejZsycAWVlZTQ5UAJ9X8CvcsYY06z7Yto+ybb8AoJhi0CanoUlKQ5vcA21iNxRdyxRnKi23ATBcuxNn7kEwmNAPPcvn/XY6XUFdDbExpK+hKxj7W2e59CAsrTJ9+in06eMe3Th8+BA//7yYd975gJ49ewNw/vkXs3v3Lj788D3Gjh3PuHETWLVqBRdffCnbtm1Bp9MzYMBA1q5dTd++/Vmy5G8GDRpCdHQ0MTEx3H33v5g27WQAUlLac9ppZ/DMM1VH5kePHseIEaMAKC8v4/vvv+W22+5izJjxANxzzwOsXbvae/sjRw5jMOhJSelASkoKKSkpJCQkkZyc4vfn61ie4CSYg5RjHR98N5bPA5UPP/yQ//znP8yePZv77ruvShQ+e/ZsOnXqxOOPP+69bNOmTej1erp16+brpjRL7MTzmf+RgTR9DuPbW1AKDqGai3DsXwv717pvpGjQxHdGWxG4aBK7oYlKRNH6frm12eYgTLEx3rUCAOPQs9CYGlZmWwgRvBRF4Z6LhtY49dMSZdabMvUD0KlTF++/d+7cAcB1111R5TYOh4PIyCgAxo2bwNdff4HVamHVqhUMGzaclJQOrFmzmosu+idLlvzNjBmnAjB48FD279/H/PlvcuDAfg4fPsiePburbeLXqVNn778PHjyA3W6nT5/+3suMRiO9evX2/n/atFNYtOhrLrhgFt26pTJixCgmTTqJlJSWDVREVT4NVPbt28djjz3G1KlTufrqq8nNzfVeFxYWxvTp03nsscdIT09n/PjxbNq0iaeeeoo5c+YQGem7PAtfSOscj7XjMD7bl485sSuzzuqMM/cAruzdOLN34zy6B7W8EFfuAVy5B7Bv/bXingpKRDt3wBKVgCYq0T1lFJWIJjoRJTwWpQl7HlisTqaHbcSkmtHEpKDvf5JvOyyEaLUURcFoqL7Hl06nQatpncMtRmPlaLOqugOIl156g/DwqvmEnj1ghgwZjl6vZ926taxevZLp00+hffv2LFz4KVlZmezatYNHH3WPmPz44w88+uiDTJt2MgMGpHPmmbPYu3cPzzzzZK1t8AxLedriodNVngbbtWvHO+98yObNG1m1agUrVizjf//7iDlzruayy65s3hMimsyngcrixYux2+389NNP/PTTT1WumzlzJk888QSKorBgwQIee+wxEhMTufTSS7nqqqt82QyfmTmpB1v3reS3tRmcOqYrYSk9IcU9VaWqKmpZPs7sPd7AxZV/CBw21LICnGUFkLWz+kE1WpTIBDRRCWgi41BMMSim6GP+xKCYolDCIlGUyoBGLcliYth2AIxjLkDRyn6SQojg0L17GgB5ebn06tXHe/lrr72EVqvliiuuQafTMXLkGP7++w+2bt3Mvfc+SEJCAk6nk7feeo20tB60b98BgA8+mM/pp5/F7bff4z3WX3/9Abi/m2saAerSpSsGg5GNGzd4p58cDge7du1k6FB35fQff/yekpISzj77H6SnD2bOnKt58slH+OWXHyVQCSCfnu2uueYarrnmmjpvc9FFF3HRRRf58mH9ZmS/FJLjwsnOL+evjZlMHV45jKgoCkpkPJrIePRpI4GK4MVSglqSg6s4B1dJrvvfJbm4SnJQS/LA5UQtzsZZnE2d+fqKghIW5Q1k+uRko1NcZJvS6NFlkH87LoQQPpSamsbYsRN4+unHufXWu+jePZXff/+F99+fz733Pui93fjxE3nyyUdISEikY8dOAAwYkM7ixd9x6aVzvLdLSkpm06YN7NixncjISP7++w8WLvwUAJvNdtxIilt4eDjnnPMP3n77NRISEujWLZWPPlpAbm6O9zY2m5WXXnqeiIgIBg0awtGjR1m3bi2DBw/x11MjGkB+ltdBo1E4eVQX5n+/nZ9WHWLy0I5o65i2URQFxRQNpmi0SWnVrlddLtTyAlzFOe4ApqwA1Vxc/Y+1FFTV+3+ASMCpKuz6//buPC7Kcv//+IsdFFHBBEIrFRFlRwZBcc3Qr5l2tDK3XFMzteSU4tdcOub5Wai5lCkuqUdNC0kzzbR9c2EpUhEFccEUSBBIRba5fn/wZY6jmCjbMHyejwePB1z3Mtf7vkfnM/dy3Y6huFZXYCGEqCb/+tf/IzLyfSIi/s1ff+Xx8MMtCA+fw//8T3/dPMHBXSgpKdEd4QAICAgkPj6Wbt3+O0bX9OkzeOedhUyZMgFLSwtcXd144403mTfvf0lKSsTHp/zCYuLEKVhaWrF06dvcuHGDXr2eoEuXbrrp/fs/TW5uLhs3riMzM4NGjRrRo8fjvPTStGrYIqKiTJSq+9cVl5Royc6u/C26tzI3N6Vp04ZkZObx6oqfuJZfxKSBHgS2d6zS1ymP0hajbl5D3cgtPUJzI5fD8cn8dNECn5AQ+gU9WuWvWZb36tXrde5uifslWY1XXc5bVFRIVtZlHBycsbCo2ACYNXExraGoT1nBOPLe6z1tb9+wQrcn1+3RZGqApYUZj3csPQT55dEL1ERdZ2JqjmmDJpg1exTzFp5YuHXhd8uOJBc76x5IKIQQQtQHUqhUQE9/FyzMTTl7+S9Op+XUSh/yC0tHpi17IKEQQghRH0ihUgF2DSzp4uUMwJdH02qlD/kFpZfe2lhKoSKEEKL+kEKlgkI1LTEBfku5wuWsqr0epiLyC0qPqNhYyakfIYQQ9YcUKhXkZN8A37alQ/zXxlEV3akfOaIihBCiHpFC5T70CSwdEvqX4+nkXi+s0de+WXbqx1oKFSGEEPWHFCr3oW2LxrR+2I7iEi3fxF2ssdfVahUFRWXXqMipHyGEEPWHFCr3wcTEhL7/d1Tlm/iLuuKhOhQVazlxLpsd3yQzd8NRXbuc+hFCCFGfyKfeffJ3e4hmja25knuTn49dppd/iypbd+bVGxxLzeZYahZJF67qPS3VxAQ6ezphYS61pRBCiPpDCpX7ZGpqQp/AR9h68DQHjqbRw9cF0wd8emlBYQlJF65yPDWbY2ezyLyarze9sa0lXq0c8GxtT4fH7LG1saiKCEIIUe8UFxezc+cOhgwpfdbc+vVr+OKLz4mK2lOlr1Nd660NhpJFCpUHEOLlzK4fU8nMyefX5D/p2K75fS3/141CPvo6mdikTIpL/jvSrZmpCW1bNMartQOerR1o8VDDcp8CKoQQ4v4cPLiflSvf1RUqou6QQuUBWFma0dPfhc9/Oc/+oxfuq1A5lprFhr0ndXcNNWtsjWdrB7xa2eP+aFNsZORZIYSockbwWLt6Sz4VH9Dj/i3Yf+QCZ/7II+ViLq4tGv/t/AVFJXz8bQrfxv8BgLNDA8b2a0/rh+3kqIkQ4m8ppaD4ziERlDJFVfeD68wt7/v/qEOHfmbdutWcO5eKjU0DgoO7MHVqGHZ2dsTHxzJ9+sv861+LWL16JRkZGXh6ejF79nw++ug/7N+/F3NzC5599nlGjRqnW+e+fZ+zdet/SEu7gL29Pf37D2TkyDGYmZXeCZmRkc6aNe8TG3uUGzeu4+3ty+TJr+Dq2pZ9+/bw73+/CUBISAArVqzWrXfLlo3s3Pkxubm5eHh4MmPGbFq2LL1p4tq1a7z//nJ+/PFbioqKaNeuPZMnT8PdvYNu+d27o9m2bTN//vknGk0gzs4P/+22mTJlAi1bPkpKymnS0s4TFjaT0ND/Ye/ez9i2bTOXL1/G2dmZQYOe4R//eA6AAQP6MGLEKJ5/fgQAH3/8EStWLGHdus26vsye/TqNGtkRHj6HhIRfWb9+DUlJJykqKuThh1144YWx9OnTD4CFC+eTn5/P9evXOHHiOKNGjWX48FH3zPJ3+7U6SaHygBrbWhHs4cSPv19m/9ELTGnhddd5Uy/lsfbzRDKybwDQO6AFz3Rvg6WF3GoshPh7SilufLYQbUZKrby+mWNbbAb8b4WLlZycHGbPfp0pU6bTuXMImZkZLFgwj1WrlhMePgeAkpISNm/ewLx5b1FcXMzrr7/K6NHD6N9/IJGRmzhw4AvWrv2AkJDutGnjyscfb2P16veYMmU6Gk0nEhOPs3Tp2+Tm5vLKK//kxo3rvPTSOB5+2IVFi5ZgYWHJhg2RTJnyIhs3fsTjjz/BtWvXWLFiCbt378fOrjG//hpHevpljh1LICJiOUVFhSxYMJdFixbw/vtrUUrx+uvTsLS05u23l2Fra8v+/Xt56aVxrFnzIW5u7hw8uJ+lS9/mlVdeIyAgkB9++JbIyFU0b+74t9vo8893MWfOAlxdXXFwaMbu3dGsWfM+YWEzaN/eg+TkU7z7bgQZGRlMnvwKwcFdiIk5qitUYmOPYGJiQnx8LO7uHSguLiYm5ihz5y7gzz8zCQubwuDBQ5gxYzZFRUVs3bqJRYsWoNF0wt7eAYDvvvuayZOnMX36DKysrO6ZpSL7tbpIoVIJoYGP8OPvl/n19J9kZN/A0b6B3vQSrZa9v5zns5/PoVWKJraWjHuyAx6t7Gupx0KIusiEunPU9c8/MygsLMTR0QknJ2ecnJx5++2llJToD+cwfvwk3dGAjh01JCYeZ/LkaZiYmDBy5Gg2blxHamoKrVu3YcuWTTzzzBAGDXoWgJYtHyE3N5dVq5YzbtxEDh7cT25uDuvXb6Fp06YAzJ//Fs899zTR0R8zefIr2NraAuDg0EzXB3Nzc+bOXUDDhqXTBg4cRGTkKgDi4mI4fvwYe/d+hZ1d6RHziRNf5tixBD75ZDuzZ88nKmoHvXuH6vo1YsRoTpw4RnLy6b/dRm3buhEa2lf396ZN6xk9ehy9e/cBwMWlBTdv3uCddxYxbtwkQkK6sWDBXAoLCzE1NeXXX+MJCelOfHwsw4a9wG+/xaPVlqDRBHLlyhXGjZvI0KEjdcXlyJFj2L9/7/8djSotVBo1smPYsBd0fbhXloru1+oghUoluDRriHcbB34/k8WBmDRG9mmnm5aRfYO1nyeSeikPgMD2zRkR2k7u3BFC3BcTExNsBvxvuad+zM1NKTawUz9t27ajd+8+zJw5HQeHZmg0nejcuSvduvXQm69Fi5a6321sbHB2flj3OlZW1gAUFRWRk3OV7OwsfHx89Zb38/OnuLiY8+fPceZMCi1bPqorUsrW0aGDB2fOnLlrX+3tHXRFCpR+eBcUFABw+nQSSikGD+6vt0xhYaFuntTUFF1xUcbT0/uehUqLFo/ofr969SqZmRmsXv0+a9d+oGvXahWFhQVcvnwJjSYIrVbLsWMJmJmZ0aCBDQMHDmLOnHCKi4s5dOgnNJogrKyscXFpQb9+A/jkk+2kpqZw8WIaKSnJAHpFxa3bvyJZKrpfq4MUKpXUN/ARfj+TxU/HLjOwaysa2Vjw/W+X2P5NMoVFWmyszBkZ6kaQh1Ntd1UIUUeZmJiAhdWd7eammJhUc6HyAObPX8jYsS9y+PAvxMQcYcGCOXh7+7J8+X8/iM3N9T9+7lYM3e0iWK1W3bKeu82jxdz87qfYTU3vPi6VVqulYcOGrF+/5Y5pFhZlXzhNUEp/+9+eqzxWVv/dl2XLT5s2nYCATrp2MzMTSkoUjo5OWFhY4OcXwNGjh7GwsMDfX4OPjx/FxUUkJSXyyy8/MXLkGADOnk1l8uTxtGvnjkbTie7de9KkSVNefHHUXftQ0SwV2a/VQUYPq6R2jzThUadGFBVr2fPzOZZH/c7mL09RWKSl/aNNWTAuUIoUIUS9ceLEcVasWMIjjzzGc88NIyJiObNmzSUuLoarV7Pve3329g7Y2zuQkPCbXntCwq9YWFjg4tKCNm3akpZ2Xm/9BQUFJCWd5LHHWgN3L4TupnVrV65fv05RUREtWrTU/WzduomffvoeKD2F8/vvCXrLJSWdvK/XadrUniZNmnLp0h96r5OUdJK1a1fpCrUuXboSE3OY+PhYOnbUYGNjg4eHF7t3R3Pp0h907twVgN27d2Jvb8+yZasYPnwUwcEhZGVl3bMf98pS1fv1fkihUkm3Dqv/ddxFfj+ThbmZKc/3cuWfz/tib2ddyz0UQoia07BhQ6KjP2HVqhVcvJhGamoKX399gBYtHqFx4yYPtM6hQ0cSFbWDTz+N4uLFNA4c2M+GDZEMGPAPbG1teeKJvjRu3IQ5c8I5efIEKSnJ/Otfb5Cfn8/AgYOA0tNLUPrhW1Bw856v2alTMG3bujFv3izi42O5eDGNlSuXsm/fHl3xM2LEaH744Vu2bdtMWtoFoqK28913X99XNhMTE4YPH0VU1A527tzBH39c5PvvvyUi4v9hZWWNpaUlUFqopKQkk5h4nICAQKD02p4vv9yHp6c3TZo0AaB5c0cyMzM4dOhn0tMv8/3337BkySKg9LTV3dwrS3Xs14qSUz9VIMD9IXZ+Xzqsfsvmtrz4VAdaPGR77wWFEMLIPPZYKxYujODDD9fy6aefYGpqir+/hiVLVvztqZa/M3ToCKytLdmxYxvLly+meXNHhg8fxbBhIwGwtbVl5co1vPfeMl55ZTIA3t4+fPDBeh5+2AUAf38NHTp48tJLY5kzZ8E9X9PMzIx3313FqlXLmTs3nPz8fB57rDULF0bQsaMGgM6dQ5g37y02bIhk3brVeHh48fzzIzh4cP9957OysiIqajsrV76Lvb0DAwcOYsyYCbp5HB2daNOm9CiPk5MzAAEBgaxfv4aQkO66+Z555nnOnz/HggVzKSoqomXLlkyYMJkNGyJJSkokKKhzuX24V5bq2K8VZaKMYBSckhIt2dnXq3Sd5uamNG3akKtXr1foYrWM7BucvZxHx3bN6+TzeO43b10mWY1XXc5bVFRIVtZlHBycsbCwrNAyNXIxrYGoT1nBOPLe6z1tb98QM7N7f17KEZUq4mjf4I7bk4UQQghROXXvq78QQggh6g0pVIQQQghhsKRQEUIIIYTBkkJFCCGEEAZLChUhhDAgRnAjphBA1b2XpVARQggDYGZWOtR7YWFBLfdEiKpR9l42M6vcDcZye7IQQhgAU1MzbGxsuXbtKgCWllb3HPZdqy19Hkx9UJ+yQt3Oq1TpAxWvXbuKjY1tpQeEk0JFCCEMhJ2dPYCuWLkXU1NTtNq6PShYRdWnrGAceW1sbHXv6cqolUJFq9Xy3nvv8cknn/DXX3+h0WiYO3cuLVu2vPfCQghhpExMTGjc2IFGjZpSUlL8t/OamZnQuHEDcnNv1Nlv3hVVn7KCceQ1MzOvsqH1a6VQWbVqFdu2bWPRokU4OTkRERHB+PHj2bNnj+4BTEIIUV+Zmppiavr3/xeam5tibW1Nfn5JnR9q/V7qU1aof3nvpcYvpi0sLGTDhg1MmzaNHj164O7uzrvvvkt6ejoHDhyo6e4IIYQQwoDVeKGSlJTE9evXCQ4O1rXZ2dnRoUMHYmJiaro7QgghhDBgNX7qJz09HQBnZ2e99ubNm+umPQjzKn5icdkTHSvyZEdjUJ/ySlbjVZ/ySlbjVd/y3kuNFyr5+fkAd1yLYmVlRW5u7gOt09TUhKZNG1a6b+Wxs7OplvUaqvqUV7Iar/qUV7Iar/qW925qvFyztrYGSq9VuVVBQQE2Ng+2U+411oAQQggh6qYaL1TKTvlkZmbqtWdmZuLo6FjT3RFCCCGEAavxQsXd3R1bW1uOHDmia8vLyyMxMRGNRlPT3RFCCCGEAavxa1QsLS0ZMWIEixcvxt7eHhcXFyIiInByciI0NLSmuyOEEEIIA1YrA75NmzaN4uJi3njjDW7evIlGo2H9+vVYWFjURneEEEIIYaBMlDxTXAghhBAGSm7SFkIIIYTBkkJFCCGEEAZLChUhhBBCGCwpVIQQQghhsKRQEUIIIYTBkkJFCCGEEAZLChUhhBBCGCwpVIQQQghhsKRQKYdWq2XFihV07doVX19fXnzxRdLS0mq7W5W2Zs0aRo4cqdd28uRJRowYga+vL7169WLz5s160+vStsjJyWHu3Ll069YNf39/hg4dSmxsrG76oUOHGDRoED4+PvTt25e9e/fqLV9QUMCbb75JcHAwfn5+/POf/yQ7O7umY1RIVlYWr7/+OkFBQfj5+TFhwgTOnDmjm25M+/VWZ8+exc/Pj+joaF2bsWXNyMigXbt2d/yUZTa2vLt27aJfv354eXnx5JNP8sUXX+imXbx4kYkTJ+Lv709ISAjLli2jpKREb/mtW7fy+OOP4+3tzbBhw0hMTKzpCBVy5MiRcvdru3btePzxxwHjylullLjDypUrVadOndS3336rTp48qcaOHatCQ0NVQUFBbXftgW3ZskW5u7urESNG6Nqys7NVp06d1KxZs1RKSoqKiopSXl5eKioqSjdPXdoWY8aMUf3791cxMTEqNTVVvfnmm8rb21udOXNGpaSkKC8vL7V06VKVkpKi1q1bpzp06KB++eUX3fLh4eGqd+/eKiYmRiUkJKinn35aDR8+vBYT3d2QIUPUs88+qxISElRKSoqaOnWqCgkJUTdu3DC6/VqmsLBQDRo0SLm5uamdO3cqpYzvPayUUt99953y8vJSGRkZKjMzU/eTn59vdHl37dqlOnTooLZs2aLOnz+vVq1apdzd3VV8fLwqLCxUoaGhasKECerUqVPq4MGDKjAwUC1fvly3fHR0tPL29la7d+9WycnJ6vXXX1eBgYEqKyurFlOVr6CgQG9/ZmZmqgMHDqh27dqpqKgoo8tblaRQuU1BQYHy8/NTW7du1bXl5uYqb29vtWfPnlrs2YNJT09XEydOVL6+vqpv3756hcrq1atVSEiIKioq0rUtWbJEhYaGKqXq1rY4d+6ccnNzU7Gxsbo2rVarevfurZYtW6bmzJmjnnnmGb1lwsLC1NixY5VSpdvJ3d1dfffdd7rpqampys3NTcXHx9dMiArKyclRYWFh6tSpU7q2kydPKjc3N5WQkGBU+/VWS5YsUS+88IJeoWKMWSMjI9VTTz1V7jRjyqvValXPnj3VokWL9NrHjh2rVq9erfbs2aM8PT1VTk6Obtr27duVv7+/rugKDQ1V77zzjm56UVGR6t69u1q9enXNhKiE69evq549e6rw8HCllDL6vJUhp35uk5SUxPXr1wkODta12dnZ0aFDB2JiYmqxZw/mxIkTWFhY8Nlnn+Hj46M3LTY2lsDAQMzN//tsyqCgIM6dO8eVK1fq1LZo2rQpkZGReHl56dpMTEwwMTEhLy+P2NhYvRxQmjUuLg6lFHFxcbq2Mq1atcLR0dHgsjZu3JglS5bg5uYGQHZ2Nhs3bsTJyQlXV1ej2q9lYmJi2LFjB4sWLdJrN8asp06dok2bNuVOM6a8Z8+e5Y8//uCpp57Sa1+/fj0TJ04kNjYWDw8PGjdurJsWFBTEtWvXOHnyJFlZWZw7d04vq7m5OQEBAQaXtTyrV68mPz+fmTNnAhh93sqQQuU26enpADg7O+u1N2/eXDetLunVqxcrV66kZcuWd0xLT0/HyclJr6158+YAXL58uU5tCzs7O7p3746lpaWu7csvv+T8+fN07dr1rlnz8/O5evUqGRkZNG3aFCsrqzvmMbSst5ozZw7BwcHs3buXhQsX0qBBA6ParwB5eXnMmDGDN954444+G1tWgNOnT5Odnc3w4cPp3LkzQ4cO5YcffgCMK+/Zs2cBuHHjBuPGjSM4OJhnn32Wb775BjCurLcr+3IxadIkmjRpAhh33sqSQuU2+fn5AHofeABWVlYUFBTURpeqzc2bN8vNCaUXltblbREfH8+sWbMIDQ2lR48e5WYt+7uwsJD8/Pw7poPhZx01ahQ7d+6kf//+vPzyy5w4ccLo9uv8+fPx8/O745s3GN97uLi4mNTUVHJzc5k6dSqRkZH4+voyYcIEDh06ZFR5r127BsDMmTPp378/GzZsoEuXLkyePNnost5u27ZtNGrUiCFDhujajDlvZZnfe5b6xdraGij98Cr7HUrfKDY2NrXVrWphbW1NYWGhXlvZG75BgwZ1dlt89dVXvPbaa/j7+7N48WKg9B/z7VnL/raxsSl3W4DhZ3V1dQVg4cKFJCQksGXLFqPar7t27SI2NpY9e/aUO92YskLpofwjR45gZmam66+npyfJycmsX7/eqPJaWFgAMG7cOP7xj38A0L59exITE/nwww/vK+vt8xha1tvt2rWLp59+Wm8fGXPeypIjKrcpO6yWmZmp156ZmYmjo2NtdKnaODk5lZsTwNHRsU5uiy1btjB16lR69uzJ6tWrdd9InJ2dy83RoEEDGjVqhJOTEzk5OXf8J2CIWbOzs9m7dy/FxcW6NlNTU1xdXcnMzDSq/bpz506ysrLo0aMHfn5++Pn5ATBv3jzGjx9vVFnLNGzYUO8DDKBt27ZkZGQYVd6y/pRda1XG1dWVixcvGlXWWyUlJZGWlnbHEUJjzVsVpFC5jbu7O7a2thw5ckTXlpeXR2JiIhqNphZ7VvU0Gg1xcXF69+kfPnyYVq1a4eDgUOe2xbZt21iwYAHDhw9n6dKleodIAwICOHr0qN78hw8fxt/fH1NTUzp27IhWq9VdVAul59AzMjIMLuuVK1cICwvj0KFDuraioiISExNp06aNUe3XxYsXs2/fPnbt2qX7AZg2bRoLFy40qqwAycnJ+Pv76/UX4Pjx47i6uhpVXg8PDxo2bEhCQoJe++nTp3nkkUfQaDQkJibqThFBadaGDRvi7u6Og4MDrVq10staXFxMbGyswWW9VWxsrG5f3cpY81aJ2r7tyBAtXbpUBQYGqq+++kpvHILCwsLa7lqlzJw5U+/25CtXriiNRqNmzpypkpOT1c6dO5WXl5eKjo7WzVNXtkVqaqry8PBQL7/88h1jFeTl5anTp08rDw8PFRERoVJSUtT69evvGEclLCxM9erVSx0+fFg3jsqt28uQjB8/XoWGhqqjR4+qU6dOqbCwMKXRaNQff/xhVPu1PLfenmxsWUtKStTgwYNVv379VExMjEpJSVH//ve/laenpzp16pTR5X3//feVn5+f2rNnj944KocPH1Y3b95UvXv3VuPGjVMnT57UjSuycuVK3fI7duxQ3t7eKjo6WjeuSKdOnQx6XJFZs2ap0aNH39FurHmrghQq5SguLlbvvPOOCgoKUr6+vurFF19UaWlptd2tSru9UFFKqYSEBPXcc88pT09P1bNnT/Wf//xHb3pd2RYffPCBcnNzK/dn5syZSimlvv/+e9W/f3/l6emp+vbtq/bu3au3juvXr6vZs2ergIAAFRAQoMLCwlR2dnZtxLmnvLw8NW/ePNWlSxfl7e2txo4dq06fPq2bbiz7tTy3FipKGV/WP//8U4WHh6suXbooLy8vNWTIEBUTE6Obbmx5N2zYoHr16qU8PDzUgAED1MGDB3XTzp07p8aMGaO8vLxUSEiIWrZsmSopKdFbft26dapbt27K29tbDRs2TCUmJtZ0hPsyfvx49eqrr5Y7zRjzVgUTpZSq7aM6QgghhBDlkWtUhBBCCGGwpFARQgghhMGSQkUIIYQQBksKFSGEEEIYLClUhBBCCGGwpFARQgghhMGSQkUIIYQQBksKFSGEEEIYLClUhBAPLD09neHDh+Pl5UVwcLDuUfRCCFFVzGu7A0KIumvTpk389ttvRERE4OjoaPSPmxdC1DwpVIQQDywnJ4fmzZvTr1+/2u6KEMJIyakfIcQD6dWrF9HR0Vy6dIl27doxcuRI2rVrx/bt2+nZsyf+/v78/PPPAHzyyScMGjQIX19fvL29GThwIF988YVuXdHR0Xh5eREbG8vgwYPx8vKiT58+fPPNN6SmpjJq1Ch8fHx44okn2Lt3r14/Ll26RFhYGIGBgfj4+DBq1CgSExP15vn8888ZMGAA3t7eBAUF8dprr5GRkVH9G0kIUWnyUEIhxANJTExk2bJlJCYm8t5773H+/HlmzJjBQw89xBtvvMHNmzcJDQ3l008/5a233mLq1Kl07NiR3Nxc1q5dS2JiIl9//TVOTk5ER0cze/ZsmjdvzpQpU3B2dmbx4sVcuHCBZs2aMXToUNzd3XnvvfdISEjgq6++wsnJiezsbJ5++mlsbGyYMmUKNjY2bNq0iePHjxMVFUWbNm2Ii4tj5MiRTJ48GY1GQ3p6OhERETz22GNs2bKltjejEOIe5NSPEOKBdOjQAXt7eywtLfH19aWgoACAYcOG0bdvX918aWlpjBs3jsmTJ+vaXFxcGDRoEHFxcTz55JMAaLVaJk2axLPPPgtAXl4e06dPZ9SoUYwZMwaARo0aMXjwYI4fP46TkxObNm0iJyeHjz76CBcXFwC6detGv379WL58OStWrCAuLg5ra2smTJiApaUlAE2aNOHYsWMopTAxMan+jSWEeGBSqAghqlT79u31/g4PDwdKC4/U1FTOnz/PkSNHACgsLNSb18/PT/e7g4MDAD4+Prq2Jk2a6NYFcOjQIdq3b4+joyPFxcUAmJqa0q1bNz777DMANBoN7777Lv3796dPnz50796dkJAQunfvXlWRhRDVSAoVIUSVatCggd7fFy5cYO7cuRw6dAgLCwtat26Nu7s7ALefeba1tb1jfX93J1FOTg7nz5/Hw8Oj3On5+fn4+fkRGRnJxo0b+fDDD4mMjKRZs2ZMmjSJkSNH3m88IUQNk0JFCFFttFotEyZMwMLCgqioKNq3b4+5uTkpKSns3r270utv1KgRgYGBzJgxo9zpZad6unbtSteuXcnPz+fw4cNs3ryZt956Cx8fH7y9vSvdDyFE9ZG7foQQ1ebq1aucPXuWZ555Bi8vL8zNS78b/fDDD0BpIVMZgYGBnD17llatWuHl5aX72b17N1FRUZiZmfH2228zePBglFLY2NjQs2dPZs6cCZTeMSSEMGxyREUIUW0cHBxwcXFh69atODk5YWdnx48//sjmzZsBKj2S7ejRo9m9ezejR49m7NixNG3alH379vHxxx8za9YsAIKCgvjwww8JDw9nwIABFBUVsW7dOpo0aUJQUFClMwohqpccURFCVKtVq1bh6OhIeHg4r776KgkJCXzwwQe0bt2a2NjYSq3b0dGR7du34+Liwvz585k0aRK///47CxcuZPTo0QB0796dxYsXk5yczJQpUwgLC8PGxobNmzfrLs4VQhguGUdFCCGEEAZLjqgIIYQQwmBJoSKEEEIIgyWFihBCCCEMlhQqQgghhDBYUqgIIYQQwmBJoSKEEEIIgyWFihBCCCEMlhQqQgghhDBYUqgIIYQQwmBJoSKEEEIIgyWFihBCCCEM1v8HMQBJKfPRrqMAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ray\n",
    "import os\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "cfg = Config()\n",
    "all_seed(cfg.seed)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
